From 14790dd03e9638130a60622f23c07da8d8340c1d Mon Sep 17 00:00:00 2001 From: Guillaume Claret Date: Sun, 12 May 2024 00:53:46 +0200 Subject: [PATCH 1/5] wip --- CoqOfPython/CoqOfPython.v | 107 +++++++++++++++++++++++++++++++------- convert_all.py | 26 --------- main.py | 2 +- 3 files changed, 90 insertions(+), 45 deletions(-) delete mode 100644 convert_all.py diff --git a/CoqOfPython/CoqOfPython.v b/CoqOfPython/CoqOfPython.v index b6128c3..03d24b2 100644 --- a/CoqOfPython/CoqOfPython.v +++ b/CoqOfPython/CoqOfPython.v @@ -66,11 +66,17 @@ Module Object. End Object. Module Pointer. + Module Mutable. + Inductive t (Value : Set) : Set := + | Make {Address A : Set} (address : Address) (to_object : A -> Object.t Value). + Arguments Make {_ _ _}. + End Mutable. + Inductive t (Value : Set) : Set := | Imm (data : Object.t Value) - | Mutable {Address A : Set} (address : Address) (to_data : A -> Object.t Value). + | Mutable (mutable : Mutable.t Value). Arguments Imm {_}. - Arguments Mutable {_ _ _}. + Arguments Mutable {_}. End Pointer. Module Value. @@ -78,18 +84,95 @@ Module Value. | Make (globals : string) (klass : string) (value : Pointer.t t). End Value. -Parameter M : Set. +Module Primitive. + Inductive t : Set -> Set := + | StateAlloc (value : Value.t) : t unit + | StateRead (mutable : Pointer.Mutable.t Value.t) : t (Object.t Value.t) + | StateWrite (mutable : Pointer.Mutable.t Value.t) (update : Value.t) : t unit. +End Primitive. + +Module LowM. + Inductive t (A : Set) : Set := + | Pure (a : A) + | CallPrimitive {B : Set} (primitive : Primitive.t B) (k : B -> t A) + | CallClosure (closure : Value.t) (args kwargs : Value.t) (k : A -> t A) + | Impossible. + Arguments Pure {_}. + Arguments CallPrimitive {_ _}. + Arguments CallClosure {_}. + Arguments Impossible {_}. + + Fixpoint bind {A : Set} (e1 : t A) (e2 : A -> t A) : t A := + match e1 with + | Pure a => e2 a + | CallPrimitive primitive k => CallPrimitive primitive (fun v => bind (k v) e2) + | CallClosure closure args kwargs k => CallClosure closure args kwargs (fun a => bind (k a) e2) + | Impossible => Impossible + end. +End LowM. + +Module Exception. + Inductive t : Set := + | Return (value : Value.t) + | Continue + | Break + | Raise (value : option Value.t). +End Exception. + +Definition M : Set := + LowM.t (Value.t + Exception.t). Parameter IsInGlobals : string -> Value.t -> string -> Prop. Parameter IsImported : string -> string -> string -> Prop. Module M. - Parameter pure : Value.t -> M. + Definition pure (v : Value.t) : M := + LowM.Pure (inl v). + + Definition bind (e1 : M) (e2 : Value.t -> M) : M := + LowM.bind e1 (fun v => match v with + | inl v => e2 v + | inr e => LowM.Pure (inr e) + end). + + (** This axiom is only used as a marker for the [monadic] tactic below, and should not appear in + the final code of the definitions once the tactic is applied. *) + Parameter run : M -> Value.t. + + Module Notations. + Notation "'let-' a := b 'in' c" := + (LowM.bind b (fun a => c)) + (at level 200, b at level 100, a name). + + Notation "'let*' a := b 'in' c" := + (bind b (fun a => c)) + (at level 200, b at level 100, a name). + + Notation "'let*' ' a ':=' b 'in' c" := + (bind b (fun a => c)) + (at level 200, a pattern, b at level 100, c at level 200). + + Notation "e (| e1 , .. , en |)" := + (run ((.. (e e1) ..) en)) + (at level 100). + + Notation "e (| |)" := + (run e) + (at level 100). + End Notations. - Parameter let_ : M -> (Value.t -> M) -> M. + Definition call (f : Value.t) (args kwargs : Value.t) : M := + LowM.CallClosure f args kwargs LowM.Pure. - Parameter call : Value.t -> Value.t -> Value.t -> M. + Definition get_object (value : Value.t) : LowM.t (Object.t Value.t) := + let 'Value.Make _ _ pointer := value in + match pointer with + | Pointer.Imm obj => + LowM.Pure obj + | Pointer.Mutable mutable => + LowM.CallPrimitive (Primitive.StateRead mutable) LowM.Pure + end. Parameter get_field : Value.t -> string -> M. @@ -132,18 +215,6 @@ Module M. Parameter while : Value.t -> M -> M -> M. - Parameter run : M -> Value.t. - - Module Notations. - Notation "e (| e1 , .. , en |)" := - (run ((.. (e e1) ..) en)) - (at level 100). - - Notation "e (| |)" := - (run e) - (at level 100). - End Notations. - (** A tactic that replaces all [M.run] markers with a bind operation. This allows to represent Rust programs without introducing explicit names for all intermediate computation results. *) diff --git a/convert_all.py b/convert_all.py deleted file mode 100644 index 5e85864..0000000 --- a/convert_all.py +++ /dev/null @@ -1,26 +0,0 @@ -import os -import subprocess -import sys - -folder_to_convert = "../execution-specs/src/ethereum" - -# for each file recursively in the folder -for root, dirs, files in os.walk(folder_to_convert): - for file in files: - if file.endswith(".py"): - # convert the file - full_path = root + "/" + file - short_path = full_path[(len(folder_to_convert) + 1):] - print("") - print("Converting file: " + short_path) - - try: - command = "python main.py " + folder_to_convert + " " + short_path - print(command) - subprocess.run(command, shell=True, check=True) - except subprocess.CalledProcessError as e: - print(f"Error occurred: {e}") - sys.exit(1) - except KeyboardInterrupt: - print("Ctrl-C pressed, interrupting the script.") - sys.exit(1) diff --git a/main.py b/main.py index 332e894..5f2596b 100644 --- a/main.py +++ b/main.py @@ -715,7 +715,7 @@ def generate_arg(node): input_file_name = sys.argv[1] -output_file_name = "../../translate-ethereum-specs/CoqOfPython/" + \ +output_file_name = "../../coq-of-python/CoqOfPython/" + \ input_file_name.replace(".py", ".v") file_content = open(input_file_name).read() From d537d383185dceb8a05e5cb3d5a407c4fc276c95 Mon Sep 17 00:00:00 2001 From: Guillaume Claret Date: Sun, 12 May 2024 12:18:16 +0200 Subject: [PATCH 2/5] Add definitions to read in the locals --- CoqOfPython/CoqOfPython.v | 203 +- CoqOfPython/ethereum/__init__.v | 12 +- CoqOfPython/ethereum/arrow_glacier/__init__.v | 6 +- CoqOfPython/ethereum/arrow_glacier/blocks.v | 4 +- CoqOfPython/ethereum/arrow_glacier/bloom.v | 68 +- CoqOfPython/ethereum/arrow_glacier/fork.v | 1359 ++++++------- .../ethereum/arrow_glacier/fork_types.v | 25 +- CoqOfPython/ethereum/arrow_glacier/state.v | 473 ++--- .../ethereum/arrow_glacier/transactions.v | 74 +- CoqOfPython/ethereum/arrow_glacier/trie.v | 551 ++--- .../ethereum/arrow_glacier/utils/__init__.v | 4 +- .../ethereum/arrow_glacier/utils/address.v | 63 +- .../arrow_glacier/utils/hexadecimal.v | 43 +- .../ethereum/arrow_glacier/utils/message.v | 73 +- .../ethereum/arrow_glacier/vm/__init__.v | 78 +- .../ethereum/arrow_glacier/vm/exceptions.v | 17 +- CoqOfPython/ethereum/arrow_glacier/vm/gas.v | 249 +-- .../arrow_glacier/vm/instructions/__init__.v | 4 +- .../vm/instructions/arithmetic.v | 471 ++--- .../arrow_glacier/vm/instructions/bitwise.v | 272 +-- .../arrow_glacier/vm/instructions/block.v | 167 +- .../vm/instructions/comparison.v | 196 +- .../vm/instructions/control_flow.v | 136 +- .../vm/instructions/environment.v | 712 +++---- .../arrow_glacier/vm/instructions/keccak.v | 69 +- .../arrow_glacier/vm/instructions/log.v | 93 +- .../arrow_glacier/vm/instructions/memory.v | 168 +- .../arrow_glacier/vm/instructions/stack.v | 384 ++-- .../arrow_glacier/vm/instructions/storage.v | 190 +- .../arrow_glacier/vm/instructions/system.v | 1059 +++++----- .../ethereum/arrow_glacier/vm/interpreter.v | 216 +- .../ethereum/arrow_glacier/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 226 ++- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- .../ethereum/arrow_glacier/vm/runtime.v | 43 +- CoqOfPython/ethereum/arrow_glacier/vm/stack.v | 32 +- CoqOfPython/ethereum/base_types.v | 1771 +++++++++-------- CoqOfPython/ethereum/berlin/__init__.v | 6 +- CoqOfPython/ethereum/berlin/blocks.v | 4 +- CoqOfPython/ethereum/berlin/bloom.v | 68 +- CoqOfPython/ethereum/berlin/fork.v | 1159 +++++------ CoqOfPython/ethereum/berlin/fork_types.v | 25 +- CoqOfPython/ethereum/berlin/state.v | 473 ++--- CoqOfPython/ethereum/berlin/transactions.v | 58 +- CoqOfPython/ethereum/berlin/trie.v | 551 ++--- CoqOfPython/ethereum/berlin/utils/__init__.v | 4 +- CoqOfPython/ethereum/berlin/utils/address.v | 63 +- .../ethereum/berlin/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/berlin/utils/message.v | 73 +- CoqOfPython/ethereum/berlin/vm/__init__.v | 78 +- CoqOfPython/ethereum/berlin/vm/exceptions.v | 17 +- CoqOfPython/ethereum/berlin/vm/gas.v | 251 +-- .../berlin/vm/instructions/__init__.v | 4 +- .../berlin/vm/instructions/arithmetic.v | 471 ++--- .../ethereum/berlin/vm/instructions/bitwise.v | 272 +-- .../ethereum/berlin/vm/instructions/block.v | 167 +- .../berlin/vm/instructions/comparison.v | 196 +- .../berlin/vm/instructions/control_flow.v | 136 +- .../berlin/vm/instructions/environment.v | 691 +++---- .../ethereum/berlin/vm/instructions/keccak.v | 69 +- .../ethereum/berlin/vm/instructions/log.v | 93 +- .../ethereum/berlin/vm/instructions/memory.v | 168 +- .../ethereum/berlin/vm/instructions/stack.v | 384 ++-- .../ethereum/berlin/vm/instructions/storage.v | 190 +- .../ethereum/berlin/vm/instructions/system.v | 1079 +++++----- CoqOfPython/ethereum/berlin/vm/interpreter.v | 216 +- CoqOfPython/ethereum/berlin/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../berlin/vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../berlin/vm/precompiled_contracts/mapping.v | 4 +- .../berlin/vm/precompiled_contracts/modexp.v | 226 ++- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../berlin/vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/berlin/vm/runtime.v | 43 +- CoqOfPython/ethereum/berlin/vm/stack.v | 32 +- CoqOfPython/ethereum/byzantium/__init__.v | 6 +- CoqOfPython/ethereum/byzantium/blocks.v | 4 +- CoqOfPython/ethereum/byzantium/bloom.v | 68 +- CoqOfPython/ethereum/byzantium/fork.v | 1060 +++++----- CoqOfPython/ethereum/byzantium/fork_types.v | 25 +- CoqOfPython/ethereum/byzantium/state.v | 417 ++-- CoqOfPython/ethereum/byzantium/transactions.v | 4 +- CoqOfPython/ethereum/byzantium/trie.v | 547 ++--- .../ethereum/byzantium/utils/__init__.v | 4 +- .../ethereum/byzantium/utils/address.v | 36 +- .../ethereum/byzantium/utils/hexadecimal.v | 43 +- .../ethereum/byzantium/utils/message.v | 55 +- CoqOfPython/ethereum/byzantium/vm/__init__.v | 70 +- .../ethereum/byzantium/vm/exceptions.v | 17 +- CoqOfPython/ethereum/byzantium/vm/gas.v | 249 +-- .../byzantium/vm/instructions/__init__.v | 4 +- .../byzantium/vm/instructions/arithmetic.v | 471 ++--- .../byzantium/vm/instructions/bitwise.v | 157 +- .../byzantium/vm/instructions/block.v | 146 +- .../byzantium/vm/instructions/comparison.v | 196 +- .../byzantium/vm/instructions/control_flow.v | 136 +- .../byzantium/vm/instructions/environment.v | 563 +++--- .../byzantium/vm/instructions/keccak.v | 69 +- .../ethereum/byzantium/vm/instructions/log.v | 93 +- .../byzantium/vm/instructions/memory.v | 168 +- .../byzantium/vm/instructions/stack.v | 384 ++-- .../byzantium/vm/instructions/storage.v | 96 +- .../byzantium/vm/instructions/system.v | 923 ++++----- .../ethereum/byzantium/vm/interpreter.v | 208 +- CoqOfPython/ethereum/byzantium/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 20 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 184 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/byzantium/vm/runtime.v | 43 +- CoqOfPython/ethereum/byzantium/vm/stack.v | 32 +- CoqOfPython/ethereum/cancun/__init__.v | 6 +- CoqOfPython/ethereum/cancun/blocks.v | 4 +- CoqOfPython/ethereum/cancun/bloom.v | 68 +- CoqOfPython/ethereum/cancun/fork.v | 1242 ++++++------ CoqOfPython/ethereum/cancun/fork_types.v | 27 +- CoqOfPython/ethereum/cancun/state.v | 562 +++--- CoqOfPython/ethereum/cancun/transactions.v | 92 +- CoqOfPython/ethereum/cancun/trie.v | 557 +++--- CoqOfPython/ethereum/cancun/utils/__init__.v | 4 +- CoqOfPython/ethereum/cancun/utils/address.v | 63 +- .../ethereum/cancun/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/cancun/utils/message.v | 73 +- CoqOfPython/ethereum/cancun/vm/__init__.v | 78 +- CoqOfPython/ethereum/cancun/vm/exceptions.v | 17 +- CoqOfPython/ethereum/cancun/vm/gas.v | 338 ++-- .../cancun/vm/instructions/__init__.v | 4 +- .../cancun/vm/instructions/arithmetic.v | 471 ++--- .../ethereum/cancun/vm/instructions/bitwise.v | 272 +-- .../ethereum/cancun/vm/instructions/block.v | 167 +- .../cancun/vm/instructions/comparison.v | 196 +- .../cancun/vm/instructions/control_flow.v | 136 +- .../cancun/vm/instructions/environment.v | 774 +++---- .../ethereum/cancun/vm/instructions/keccak.v | 69 +- .../ethereum/cancun/vm/instructions/log.v | 93 +- .../ethereum/cancun/vm/instructions/memory.v | 235 +-- .../ethereum/cancun/vm/instructions/stack.v | 396 ++-- .../ethereum/cancun/vm/instructions/storage.v | 258 +-- .../ethereum/cancun/vm/instructions/system.v | 1087 +++++----- CoqOfPython/ethereum/cancun/vm/interpreter.v | 226 ++- CoqOfPython/ethereum/cancun/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 24 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../cancun/vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../cancun/vm/precompiled_contracts/mapping.v | 4 +- .../cancun/vm/precompiled_contracts/modexp.v | 226 ++- .../precompiled_contracts/point_evaluation.v | 65 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../cancun/vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/cancun/vm/runtime.v | 43 +- CoqOfPython/ethereum/cancun/vm/stack.v | 32 +- .../ethereum/constantinople/__init__.v | 6 +- CoqOfPython/ethereum/constantinople/blocks.v | 4 +- CoqOfPython/ethereum/constantinople/bloom.v | 68 +- CoqOfPython/ethereum/constantinople/fork.v | 1060 +++++----- .../ethereum/constantinople/fork_types.v | 25 +- CoqOfPython/ethereum/constantinople/state.v | 417 ++-- .../ethereum/constantinople/transactions.v | 4 +- CoqOfPython/ethereum/constantinople/trie.v | 547 ++--- .../ethereum/constantinople/utils/__init__.v | 4 +- .../ethereum/constantinople/utils/address.v | 63 +- .../constantinople/utils/hexadecimal.v | 43 +- .../ethereum/constantinople/utils/message.v | 55 +- .../ethereum/constantinople/vm/__init__.v | 70 +- .../ethereum/constantinople/vm/exceptions.v | 17 +- CoqOfPython/ethereum/constantinople/vm/gas.v | 251 +-- .../constantinople/vm/instructions/__init__.v | 4 +- .../vm/instructions/arithmetic.v | 471 ++--- .../constantinople/vm/instructions/bitwise.v | 272 +-- .../constantinople/vm/instructions/block.v | 146 +- .../vm/instructions/comparison.v | 196 +- .../vm/instructions/control_flow.v | 136 +- .../vm/instructions/environment.v | 606 +++--- .../constantinople/vm/instructions/keccak.v | 69 +- .../constantinople/vm/instructions/log.v | 93 +- .../constantinople/vm/instructions/memory.v | 168 +- .../constantinople/vm/instructions/stack.v | 384 ++-- .../constantinople/vm/instructions/storage.v | 96 +- .../constantinople/vm/instructions/system.v | 1017 +++++----- .../ethereum/constantinople/vm/interpreter.v | 208 +- .../ethereum/constantinople/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 20 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 184 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- .../ethereum/constantinople/vm/runtime.v | 43 +- .../ethereum/constantinople/vm/stack.v | 32 +- CoqOfPython/ethereum/crypto/__init__.v | 4 +- CoqOfPython/ethereum/crypto/alt_bn128.v | 285 +-- CoqOfPython/ethereum/crypto/blake2.v | 378 ++-- CoqOfPython/ethereum/crypto/elliptic_curve.v | 295 +-- CoqOfPython/ethereum/crypto/finite_field.v | 1038 +++++----- CoqOfPython/ethereum/crypto/hash.v | 34 +- CoqOfPython/ethereum/dao_fork/__init__.v | 6 +- CoqOfPython/ethereum/dao_fork/blocks.v | 4 +- CoqOfPython/ethereum/dao_fork/bloom.v | 68 +- CoqOfPython/ethereum/dao_fork/dao.v | 31 +- CoqOfPython/ethereum/dao_fork/fork.v | 991 ++++----- CoqOfPython/ethereum/dao_fork/fork_types.v | 25 +- CoqOfPython/ethereum/dao_fork/state.v | 356 ++-- CoqOfPython/ethereum/dao_fork/transactions.v | 4 +- CoqOfPython/ethereum/dao_fork/trie.v | 547 ++--- .../ethereum/dao_fork/utils/__init__.v | 4 +- CoqOfPython/ethereum/dao_fork/utils/address.v | 36 +- .../ethereum/dao_fork/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/dao_fork/utils/message.v | 55 +- CoqOfPython/ethereum/dao_fork/vm/__init__.v | 30 +- CoqOfPython/ethereum/dao_fork/vm/exceptions.v | 17 +- CoqOfPython/ethereum/dao_fork/vm/gas.v | 228 +-- .../dao_fork/vm/instructions/__init__.v | 4 +- .../dao_fork/vm/instructions/arithmetic.v | 471 ++--- .../dao_fork/vm/instructions/bitwise.v | 157 +- .../ethereum/dao_fork/vm/instructions/block.v | 146 +- .../dao_fork/vm/instructions/comparison.v | 196 +- .../dao_fork/vm/instructions/control_flow.v | 136 +- .../dao_fork/vm/instructions/environment.v | 459 ++--- .../dao_fork/vm/instructions/keccak.v | 69 +- .../ethereum/dao_fork/vm/instructions/log.v | 87 +- .../dao_fork/vm/instructions/memory.v | 168 +- .../ethereum/dao_fork/vm/instructions/stack.v | 384 ++-- .../dao_fork/vm/instructions/storage.v | 90 +- .../dao_fork/vm/instructions/system.v | 665 ++++--- .../ethereum/dao_fork/vm/interpreter.v | 176 +- CoqOfPython/ethereum/dao_fork/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 12 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/dao_fork/vm/runtime.v | 43 +- CoqOfPython/ethereum/dao_fork/vm/stack.v | 32 +- CoqOfPython/ethereum/ethash.v | 391 ++-- CoqOfPython/ethereum/exceptions.v | 4 +- CoqOfPython/ethereum/fork_criteria.v | 120 +- CoqOfPython/ethereum/frontier/__init__.v | 6 +- CoqOfPython/ethereum/frontier/blocks.v | 4 +- CoqOfPython/ethereum/frontier/bloom.v | 68 +- CoqOfPython/ethereum/frontier/fork.v | 961 ++++----- CoqOfPython/ethereum/frontier/fork_types.v | 25 +- CoqOfPython/ethereum/frontier/state.v | 356 ++-- CoqOfPython/ethereum/frontier/transactions.v | 4 +- CoqOfPython/ethereum/frontier/trie.v | 543 ++--- .../ethereum/frontier/utils/__init__.v | 4 +- CoqOfPython/ethereum/frontier/utils/address.v | 36 +- .../ethereum/frontier/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/frontier/utils/message.v | 55 +- CoqOfPython/ethereum/frontier/vm/__init__.v | 34 +- CoqOfPython/ethereum/frontier/vm/exceptions.v | 17 +- CoqOfPython/ethereum/frontier/vm/gas.v | 228 +-- .../frontier/vm/instructions/__init__.v | 4 +- .../frontier/vm/instructions/arithmetic.v | 471 ++--- .../frontier/vm/instructions/bitwise.v | 157 +- .../ethereum/frontier/vm/instructions/block.v | 146 +- .../frontier/vm/instructions/comparison.v | 196 +- .../frontier/vm/instructions/control_flow.v | 136 +- .../frontier/vm/instructions/environment.v | 459 ++--- .../frontier/vm/instructions/keccak.v | 69 +- .../ethereum/frontier/vm/instructions/log.v | 87 +- .../frontier/vm/instructions/memory.v | 168 +- .../ethereum/frontier/vm/instructions/stack.v | 384 ++-- .../frontier/vm/instructions/storage.v | 90 +- .../frontier/vm/instructions/system.v | 586 +++--- .../ethereum/frontier/vm/interpreter.v | 184 +- CoqOfPython/ethereum/frontier/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 12 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/frontier/vm/runtime.v | 43 +- CoqOfPython/ethereum/frontier/vm/stack.v | 32 +- CoqOfPython/ethereum/genesis.v | 125 +- CoqOfPython/ethereum/gray_glacier/__init__.v | 6 +- CoqOfPython/ethereum/gray_glacier/blocks.v | 4 +- CoqOfPython/ethereum/gray_glacier/bloom.v | 68 +- CoqOfPython/ethereum/gray_glacier/fork.v | 1359 ++++++------- .../ethereum/gray_glacier/fork_types.v | 25 +- CoqOfPython/ethereum/gray_glacier/state.v | 473 ++--- .../ethereum/gray_glacier/transactions.v | 74 +- CoqOfPython/ethereum/gray_glacier/trie.v | 551 ++--- .../ethereum/gray_glacier/utils/__init__.v | 4 +- .../ethereum/gray_glacier/utils/address.v | 63 +- .../ethereum/gray_glacier/utils/hexadecimal.v | 43 +- .../ethereum/gray_glacier/utils/message.v | 73 +- .../ethereum/gray_glacier/vm/__init__.v | 78 +- .../ethereum/gray_glacier/vm/exceptions.v | 17 +- CoqOfPython/ethereum/gray_glacier/vm/gas.v | 249 +-- .../gray_glacier/vm/instructions/__init__.v | 4 +- .../gray_glacier/vm/instructions/arithmetic.v | 471 ++--- .../gray_glacier/vm/instructions/bitwise.v | 272 +-- .../gray_glacier/vm/instructions/block.v | 167 +- .../gray_glacier/vm/instructions/comparison.v | 196 +- .../vm/instructions/control_flow.v | 136 +- .../vm/instructions/environment.v | 712 +++---- .../gray_glacier/vm/instructions/keccak.v | 69 +- .../gray_glacier/vm/instructions/log.v | 93 +- .../gray_glacier/vm/instructions/memory.v | 168 +- .../gray_glacier/vm/instructions/stack.v | 384 ++-- .../gray_glacier/vm/instructions/storage.v | 190 +- .../gray_glacier/vm/instructions/system.v | 1059 +++++----- .../ethereum/gray_glacier/vm/interpreter.v | 216 +- CoqOfPython/ethereum/gray_glacier/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 226 ++- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- .../ethereum/gray_glacier/vm/runtime.v | 43 +- CoqOfPython/ethereum/gray_glacier/vm/stack.v | 32 +- CoqOfPython/ethereum/homestead/__init__.v | 6 +- CoqOfPython/ethereum/homestead/blocks.v | 4 +- CoqOfPython/ethereum/homestead/bloom.v | 68 +- CoqOfPython/ethereum/homestead/fork.v | 973 ++++----- CoqOfPython/ethereum/homestead/fork_types.v | 25 +- CoqOfPython/ethereum/homestead/state.v | 356 ++-- CoqOfPython/ethereum/homestead/transactions.v | 4 +- CoqOfPython/ethereum/homestead/trie.v | 547 ++--- .../ethereum/homestead/utils/__init__.v | 4 +- .../ethereum/homestead/utils/address.v | 36 +- .../ethereum/homestead/utils/hexadecimal.v | 43 +- .../ethereum/homestead/utils/message.v | 55 +- CoqOfPython/ethereum/homestead/vm/__init__.v | 34 +- .../ethereum/homestead/vm/exceptions.v | 17 +- CoqOfPython/ethereum/homestead/vm/gas.v | 228 +-- .../homestead/vm/instructions/__init__.v | 4 +- .../homestead/vm/instructions/arithmetic.v | 471 ++--- .../homestead/vm/instructions/bitwise.v | 157 +- .../homestead/vm/instructions/block.v | 146 +- .../homestead/vm/instructions/comparison.v | 196 +- .../homestead/vm/instructions/control_flow.v | 136 +- .../homestead/vm/instructions/environment.v | 459 ++--- .../homestead/vm/instructions/keccak.v | 69 +- .../ethereum/homestead/vm/instructions/log.v | 87 +- .../homestead/vm/instructions/memory.v | 168 +- .../homestead/vm/instructions/stack.v | 384 ++-- .../homestead/vm/instructions/storage.v | 90 +- .../homestead/vm/instructions/system.v | 665 ++++--- .../ethereum/homestead/vm/interpreter.v | 182 +- CoqOfPython/ethereum/homestead/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 12 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/homestead/vm/runtime.v | 43 +- CoqOfPython/ethereum/homestead/vm/stack.v | 32 +- CoqOfPython/ethereum/istanbul/__init__.v | 6 +- CoqOfPython/ethereum/istanbul/blocks.v | 4 +- CoqOfPython/ethereum/istanbul/bloom.v | 68 +- CoqOfPython/ethereum/istanbul/fork.v | 1060 +++++----- CoqOfPython/ethereum/istanbul/fork_types.v | 25 +- CoqOfPython/ethereum/istanbul/state.v | 473 ++--- CoqOfPython/ethereum/istanbul/transactions.v | 4 +- CoqOfPython/ethereum/istanbul/trie.v | 547 ++--- .../ethereum/istanbul/utils/__init__.v | 4 +- CoqOfPython/ethereum/istanbul/utils/address.v | 63 +- .../ethereum/istanbul/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/istanbul/utils/message.v | 55 +- CoqOfPython/ethereum/istanbul/vm/__init__.v | 70 +- CoqOfPython/ethereum/istanbul/vm/exceptions.v | 17 +- CoqOfPython/ethereum/istanbul/vm/gas.v | 255 +-- .../istanbul/vm/instructions/__init__.v | 4 +- .../istanbul/vm/instructions/arithmetic.v | 471 ++--- .../istanbul/vm/instructions/bitwise.v | 272 +-- .../ethereum/istanbul/vm/instructions/block.v | 167 +- .../istanbul/vm/instructions/comparison.v | 196 +- .../istanbul/vm/instructions/control_flow.v | 136 +- .../istanbul/vm/instructions/environment.v | 631 +++--- .../istanbul/vm/instructions/keccak.v | 69 +- .../ethereum/istanbul/vm/instructions/log.v | 93 +- .../istanbul/vm/instructions/memory.v | 168 +- .../ethereum/istanbul/vm/instructions/stack.v | 384 ++-- .../istanbul/vm/instructions/storage.v | 160 +- .../istanbul/vm/instructions/system.v | 1017 +++++----- .../ethereum/istanbul/vm/interpreter.v | 216 +- CoqOfPython/ethereum/istanbul/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 184 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/istanbul/vm/runtime.v | 43 +- CoqOfPython/ethereum/istanbul/vm/stack.v | 32 +- CoqOfPython/ethereum/london/__init__.v | 6 +- CoqOfPython/ethereum/london/blocks.v | 4 +- CoqOfPython/ethereum/london/bloom.v | 68 +- CoqOfPython/ethereum/london/fork.v | 1371 ++++++------- CoqOfPython/ethereum/london/fork_types.v | 25 +- CoqOfPython/ethereum/london/state.v | 473 ++--- CoqOfPython/ethereum/london/transactions.v | 74 +- CoqOfPython/ethereum/london/trie.v | 551 ++--- CoqOfPython/ethereum/london/utils/__init__.v | 4 +- CoqOfPython/ethereum/london/utils/address.v | 63 +- .../ethereum/london/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/london/utils/message.v | 73 +- CoqOfPython/ethereum/london/vm/__init__.v | 78 +- CoqOfPython/ethereum/london/vm/exceptions.v | 17 +- CoqOfPython/ethereum/london/vm/gas.v | 249 +-- .../london/vm/instructions/__init__.v | 4 +- .../london/vm/instructions/arithmetic.v | 471 ++--- .../ethereum/london/vm/instructions/bitwise.v | 272 +-- .../ethereum/london/vm/instructions/block.v | 167 +- .../london/vm/instructions/comparison.v | 196 +- .../london/vm/instructions/control_flow.v | 136 +- .../london/vm/instructions/environment.v | 712 +++---- .../ethereum/london/vm/instructions/keccak.v | 69 +- .../ethereum/london/vm/instructions/log.v | 93 +- .../ethereum/london/vm/instructions/memory.v | 168 +- .../ethereum/london/vm/instructions/stack.v | 384 ++-- .../ethereum/london/vm/instructions/storage.v | 190 +- .../ethereum/london/vm/instructions/system.v | 1059 +++++----- CoqOfPython/ethereum/london/vm/interpreter.v | 216 +- CoqOfPython/ethereum/london/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../london/vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../london/vm/precompiled_contracts/mapping.v | 4 +- .../london/vm/precompiled_contracts/modexp.v | 226 ++- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../london/vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/london/vm/runtime.v | 43 +- CoqOfPython/ethereum/london/vm/stack.v | 32 +- CoqOfPython/ethereum/muir_glacier/__init__.v | 6 +- CoqOfPython/ethereum/muir_glacier/blocks.v | 4 +- CoqOfPython/ethereum/muir_glacier/bloom.v | 68 +- CoqOfPython/ethereum/muir_glacier/fork.v | 1060 +++++----- .../ethereum/muir_glacier/fork_types.v | 25 +- CoqOfPython/ethereum/muir_glacier/state.v | 473 ++--- .../ethereum/muir_glacier/transactions.v | 4 +- CoqOfPython/ethereum/muir_glacier/trie.v | 547 ++--- .../ethereum/muir_glacier/utils/__init__.v | 4 +- .../ethereum/muir_glacier/utils/address.v | 63 +- .../ethereum/muir_glacier/utils/hexadecimal.v | 43 +- .../ethereum/muir_glacier/utils/message.v | 55 +- .../ethereum/muir_glacier/vm/__init__.v | 70 +- .../ethereum/muir_glacier/vm/exceptions.v | 17 +- CoqOfPython/ethereum/muir_glacier/vm/gas.v | 255 +-- .../muir_glacier/vm/instructions/__init__.v | 4 +- .../muir_glacier/vm/instructions/arithmetic.v | 471 ++--- .../muir_glacier/vm/instructions/bitwise.v | 272 +-- .../muir_glacier/vm/instructions/block.v | 167 +- .../muir_glacier/vm/instructions/comparison.v | 196 +- .../vm/instructions/control_flow.v | 136 +- .../vm/instructions/environment.v | 631 +++--- .../muir_glacier/vm/instructions/keccak.v | 69 +- .../muir_glacier/vm/instructions/log.v | 93 +- .../muir_glacier/vm/instructions/memory.v | 168 +- .../muir_glacier/vm/instructions/stack.v | 384 ++-- .../muir_glacier/vm/instructions/storage.v | 160 +- .../muir_glacier/vm/instructions/system.v | 1017 +++++----- .../ethereum/muir_glacier/vm/interpreter.v | 216 +- CoqOfPython/ethereum/muir_glacier/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 184 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- .../ethereum/muir_glacier/vm/runtime.v | 43 +- CoqOfPython/ethereum/muir_glacier/vm/stack.v | 32 +- CoqOfPython/ethereum/paris/__init__.v | 6 +- CoqOfPython/ethereum/paris/blocks.v | 4 +- CoqOfPython/ethereum/paris/bloom.v | 68 +- CoqOfPython/ethereum/paris/fork.v | 1018 +++++----- CoqOfPython/ethereum/paris/fork_types.v | 25 +- CoqOfPython/ethereum/paris/state.v | 460 +++-- CoqOfPython/ethereum/paris/transactions.v | 74 +- CoqOfPython/ethereum/paris/trie.v | 551 ++--- CoqOfPython/ethereum/paris/utils/__init__.v | 4 +- CoqOfPython/ethereum/paris/utils/address.v | 63 +- .../ethereum/paris/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/paris/utils/message.v | 73 +- CoqOfPython/ethereum/paris/vm/__init__.v | 78 +- CoqOfPython/ethereum/paris/vm/exceptions.v | 17 +- CoqOfPython/ethereum/paris/vm/gas.v | 249 +-- .../ethereum/paris/vm/instructions/__init__.v | 4 +- .../paris/vm/instructions/arithmetic.v | 471 ++--- .../ethereum/paris/vm/instructions/bitwise.v | 272 +-- .../ethereum/paris/vm/instructions/block.v | 167 +- .../paris/vm/instructions/comparison.v | 196 +- .../paris/vm/instructions/control_flow.v | 136 +- .../paris/vm/instructions/environment.v | 712 +++---- .../ethereum/paris/vm/instructions/keccak.v | 69 +- .../ethereum/paris/vm/instructions/log.v | 93 +- .../ethereum/paris/vm/instructions/memory.v | 168 +- .../ethereum/paris/vm/instructions/stack.v | 384 ++-- .../ethereum/paris/vm/instructions/storage.v | 190 +- .../ethereum/paris/vm/instructions/system.v | 1059 +++++----- CoqOfPython/ethereum/paris/vm/interpreter.v | 216 +- CoqOfPython/ethereum/paris/vm/memory.v | 61 +- .../paris/vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../paris/vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../paris/vm/precompiled_contracts/identity.v | 33 +- .../paris/vm/precompiled_contracts/mapping.v | 4 +- .../paris/vm/precompiled_contracts/modexp.v | 226 ++- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../paris/vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/paris/vm/runtime.v | 43 +- CoqOfPython/ethereum/paris/vm/stack.v | 32 +- CoqOfPython/ethereum/rlp.v | 856 ++++---- CoqOfPython/ethereum/shanghai/__init__.v | 6 +- CoqOfPython/ethereum/shanghai/blocks.v | 4 +- CoqOfPython/ethereum/shanghai/bloom.v | 68 +- CoqOfPython/ethereum/shanghai/fork.v | 1094 +++++----- CoqOfPython/ethereum/shanghai/fork_types.v | 25 +- CoqOfPython/ethereum/shanghai/state.v | 473 ++--- CoqOfPython/ethereum/shanghai/transactions.v | 74 +- CoqOfPython/ethereum/shanghai/trie.v | 557 +++--- .../ethereum/shanghai/utils/__init__.v | 4 +- CoqOfPython/ethereum/shanghai/utils/address.v | 63 +- .../ethereum/shanghai/utils/hexadecimal.v | 43 +- CoqOfPython/ethereum/shanghai/utils/message.v | 73 +- CoqOfPython/ethereum/shanghai/vm/__init__.v | 78 +- CoqOfPython/ethereum/shanghai/vm/exceptions.v | 17 +- CoqOfPython/ethereum/shanghai/vm/gas.v | 260 +-- .../shanghai/vm/instructions/__init__.v | 4 +- .../shanghai/vm/instructions/arithmetic.v | 471 ++--- .../shanghai/vm/instructions/bitwise.v | 272 +-- .../ethereum/shanghai/vm/instructions/block.v | 167 +- .../shanghai/vm/instructions/comparison.v | 196 +- .../shanghai/vm/instructions/control_flow.v | 136 +- .../shanghai/vm/instructions/environment.v | 712 +++---- .../shanghai/vm/instructions/keccak.v | 69 +- .../ethereum/shanghai/vm/instructions/log.v | 93 +- .../shanghai/vm/instructions/memory.v | 168 +- .../ethereum/shanghai/vm/instructions/stack.v | 396 ++-- .../shanghai/vm/instructions/storage.v | 190 +- .../shanghai/vm/instructions/system.v | 1089 +++++----- .../ethereum/shanghai/vm/interpreter.v | 216 +- CoqOfPython/ethereum/shanghai/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 22 +- .../vm/precompiled_contracts/alt_bn128.v | 261 +-- .../vm/precompiled_contracts/blake2f.v | 57 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/modexp.v | 226 ++- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- CoqOfPython/ethereum/shanghai/vm/runtime.v | 43 +- CoqOfPython/ethereum/shanghai/vm/stack.v | 32 +- .../ethereum/spurious_dragon/__init__.v | 6 +- CoqOfPython/ethereum/spurious_dragon/blocks.v | 4 +- CoqOfPython/ethereum/spurious_dragon/bloom.v | 68 +- CoqOfPython/ethereum/spurious_dragon/fork.v | 1048 +++++----- .../ethereum/spurious_dragon/fork_types.v | 25 +- CoqOfPython/ethereum/spurious_dragon/state.v | 417 ++-- .../ethereum/spurious_dragon/transactions.v | 4 +- CoqOfPython/ethereum/spurious_dragon/trie.v | 547 ++--- .../ethereum/spurious_dragon/utils/__init__.v | 4 +- .../ethereum/spurious_dragon/utils/address.v | 36 +- .../spurious_dragon/utils/hexadecimal.v | 43 +- .../ethereum/spurious_dragon/utils/message.v | 55 +- .../ethereum/spurious_dragon/vm/__init__.v | 70 +- .../ethereum/spurious_dragon/vm/exceptions.v | 17 +- CoqOfPython/ethereum/spurious_dragon/vm/gas.v | 247 +-- .../vm/instructions/__init__.v | 4 +- .../vm/instructions/arithmetic.v | 471 ++--- .../spurious_dragon/vm/instructions/bitwise.v | 157 +- .../spurious_dragon/vm/instructions/block.v | 146 +- .../vm/instructions/comparison.v | 196 +- .../vm/instructions/control_flow.v | 136 +- .../vm/instructions/environment.v | 459 ++--- .../spurious_dragon/vm/instructions/keccak.v | 69 +- .../spurious_dragon/vm/instructions/log.v | 87 +- .../spurious_dragon/vm/instructions/memory.v | 168 +- .../spurious_dragon/vm/instructions/stack.v | 384 ++-- .../spurious_dragon/vm/instructions/storage.v | 90 +- .../spurious_dragon/vm/instructions/system.v | 743 +++---- .../ethereum/spurious_dragon/vm/interpreter.v | 208 +- .../ethereum/spurious_dragon/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 12 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- .../ethereum/spurious_dragon/vm/runtime.v | 43 +- .../ethereum/spurious_dragon/vm/stack.v | 32 +- .../ethereum/tangerine_whistle/__init__.v | 6 +- .../ethereum/tangerine_whistle/blocks.v | 4 +- .../ethereum/tangerine_whistle/bloom.v | 68 +- CoqOfPython/ethereum/tangerine_whistle/fork.v | 973 ++++----- .../ethereum/tangerine_whistle/fork_types.v | 25 +- .../ethereum/tangerine_whistle/state.v | 356 ++-- .../ethereum/tangerine_whistle/transactions.v | 4 +- CoqOfPython/ethereum/tangerine_whistle/trie.v | 547 ++--- .../tangerine_whistle/utils/__init__.v | 4 +- .../tangerine_whistle/utils/address.v | 36 +- .../tangerine_whistle/utils/hexadecimal.v | 43 +- .../tangerine_whistle/utils/message.v | 55 +- .../ethereum/tangerine_whistle/vm/__init__.v | 34 +- .../tangerine_whistle/vm/exceptions.v | 17 +- .../ethereum/tangerine_whistle/vm/gas.v | 247 +-- .../vm/instructions/__init__.v | 4 +- .../vm/instructions/arithmetic.v | 471 ++--- .../vm/instructions/bitwise.v | 157 +- .../tangerine_whistle/vm/instructions/block.v | 146 +- .../vm/instructions/comparison.v | 196 +- .../vm/instructions/control_flow.v | 136 +- .../vm/instructions/environment.v | 459 ++--- .../vm/instructions/keccak.v | 69 +- .../tangerine_whistle/vm/instructions/log.v | 87 +- .../vm/instructions/memory.v | 168 +- .../tangerine_whistle/vm/instructions/stack.v | 384 ++-- .../vm/instructions/storage.v | 90 +- .../vm/instructions/system.v | 727 +++---- .../tangerine_whistle/vm/interpreter.v | 182 +- .../ethereum/tangerine_whistle/vm/memory.v | 61 +- .../vm/precompiled_contracts/__init__.v | 12 +- .../vm/precompiled_contracts/ecrecover.v | 87 +- .../vm/precompiled_contracts/identity.v | 33 +- .../vm/precompiled_contracts/mapping.v | 4 +- .../vm/precompiled_contracts/ripemd160.v | 41 +- .../vm/precompiled_contracts/sha256.v | 35 +- .../ethereum/tangerine_whistle/vm/runtime.v | 43 +- .../ethereum/tangerine_whistle/vm/stack.v | 32 +- CoqOfPython/ethereum/trace.v | 13 +- CoqOfPython/ethereum/utils/__init__.v | 4 +- CoqOfPython/ethereum/utils/byte.v | 22 +- CoqOfPython/ethereum/utils/ensure.v | 13 +- CoqOfPython/ethereum/utils/hexadecimal.v | 141 +- CoqOfPython/ethereum/utils/numeric.v | 133 +- CoqOfPython/ethereum/utils/safe_arithmetic.v | 16 +- main.py | 11 +- 663 files changed, 63112 insertions(+), 58806 deletions(-) diff --git a/CoqOfPython/CoqOfPython.v b/CoqOfPython/CoqOfPython.v index 03d24b2..dc29d21 100644 --- a/CoqOfPython/CoqOfPython.v +++ b/CoqOfPython/CoqOfPython.v @@ -15,6 +15,19 @@ Global Open Scope type_scope. Export List.ListNotations. +Module Dict. + Definition t (Value : Set) : Set := + list (string * Value). + + Parameter read : forall {Value : Set}, t Value -> string -> option Value. + + Parameter write : forall {Value : Set}, t Value -> string -> Value -> t Value. +End Dict. + +Module Globals. + Definition t : Set := string. +End Globals. + Module Data. (** This type is not accessible directly in Python, as only object are. We use this type internally to represent integers, closures, ... that can be made accessible in a special @@ -30,10 +43,10 @@ Module Data. a list when the number of elements is not statically known. *) | List (items : list Value) | Set_ (items : list Value) - | Dict (dict : list (string * Value)) + | Dict (dict : Dict.t Value) | Closure {Value M : Set} (f : Value -> Value -> M) | Klass {Value M : Set} - (bases : list (string * string)) + (bases : list (Globals.t * string)) (class_methods : list (string * (Value -> Value -> M))) (methods : list (string * (Value -> Value -> M))). Arguments Ellipsis {_}. @@ -52,7 +65,7 @@ End Data. Module Object. Record t {Value : Set} : Set := { internal : option (Data.t Value); - fields : list (string * Value); + fields : Dict.t Value; }. Arguments t : clear implicits. Arguments Build_t {_}. @@ -81,28 +94,74 @@ End Pointer. Module Value. Inductive t : Set := - | Make (globals : string) (klass : string) (value : Pointer.t t). + | Make (globals : Globals.t) (klass : string) (value : Pointer.t t). End Value. +Module Locals. + Definition t : Set := Pointer.Mutable.t Value.t. +End Locals. + +(** ** Constants *) +Module Constant. + Definition None_ : Value.t := + Value.Make "builtins" "NoneType" (Pointer.Imm {| + Object.internal := None; + Object.fields := []; + |}). + + Definition ellipsis : Value.t := + Value.Make "builtins" "ellipsis" (Pointer.Imm (Object.wrapper Data.Ellipsis)). + + Definition bool (b : bool) : Value.t := + Value.Make "builtins" "bool" (Pointer.Imm (Object.wrapper (Data.Bool b))). + + Definition int (z : Z) : Value.t := + Value.Make "builtins" "int" (Pointer.Imm (Object.wrapper (Data.Integer z))). + + Definition float (f : string) : Value.t := + Value.Make "builtins" "float" (Pointer.Imm (Object.wrapper (Data.Float f))). + + Definition str (s : string) : Value.t := + Value.Make "builtins" "str" (Pointer.Imm (Object.wrapper (Data.String s))). + + Definition bytes (b : string) : Value.t := + Value.Make "builtins" "bytes" (Pointer.Imm (Object.wrapper (Data.String b))). +End Constant. + +Definition make_tuple (items : list Value.t) : Value.t := + Value.Make "builtins" "tuple" (Pointer.Imm (Object.wrapper (Data.Tuple items))). + +Definition make_list (items : list Value.t) : Value.t := + Value.Make "builtins" "list" (Pointer.Imm (Object.wrapper (Data.List items))). + +Definition make_set (items : list Value.t) : Value.t := + Value.Make "builtins" "set" (Pointer.Imm (Object.wrapper (Data.Set_ items))). + +Parameter order_dict : list (string * Value.t) -> list (string * Value.t). + +Definition make_dict (dict : list (string * Value.t)) : Value.t := + Value.Make "builtins" "dict" (Pointer.Imm (Object.wrapper (Data.Dict (order_dict dict)))). + Module Primitive. Inductive t : Set -> Set := - | StateAlloc (value : Value.t) : t unit + | StateAlloc (object : Object.t Value.t) : t (Pointer.Mutable.t Value.t) | StateRead (mutable : Pointer.Mutable.t Value.t) : t (Object.t Value.t) - | StateWrite (mutable : Pointer.Mutable.t Value.t) (update : Value.t) : t unit. + | StateWrite (mutable : Pointer.Mutable.t Value.t) (update : Object.t Value.t) : t unit + | GetInGlobals (globals : Globals.t) (name : string) : t Value.t. End Primitive. Module LowM. Inductive t (A : Set) : Set := | Pure (a : A) | CallPrimitive {B : Set} (primitive : Primitive.t B) (k : B -> t A) - | CallClosure (closure : Value.t) (args kwargs : Value.t) (k : A -> t A) + | CallClosure {B : Set} (closure : Value.t) (args kwargs : Value.t) (k : B -> t A) | Impossible. Arguments Pure {_}. Arguments CallPrimitive {_ _}. - Arguments CallClosure {_}. + Arguments CallClosure {_ _}. Arguments Impossible {_}. - Fixpoint bind {A : Set} (e1 : t A) (e2 : A -> t A) : t A := + Fixpoint bind {A B : Set} (e1 : t A) (e2 : A -> t B) : t B := match e1 with | Pure a => e2 a | CallPrimitive primitive k => CallPrimitive primitive (fun v => bind (k v) e2) @@ -136,6 +195,9 @@ Module M. | inr e => LowM.Pure (inr e) end). + Definition impossible : M := + LowM.Impossible. + (** This axiom is only used as a marker for the [monadic] tactic below, and should not appear in the final code of the definitions once the tactic is applied. *) Parameter run : M -> Value.t. @@ -161,6 +223,10 @@ Module M. (run e) (at level 100). End Notations. + Import Notations. + + Definition call_primitive {A : Set} (primitive : Primitive.t A) : LowM.t A := + LowM.CallPrimitive primitive LowM.Pure. Definition call (f : Value.t) (args kwargs : Value.t) : M := LowM.CallClosure f args kwargs LowM.Pure. @@ -170,20 +236,69 @@ Module M. match pointer with | Pointer.Imm obj => LowM.Pure obj - | Pointer.Mutable mutable => - LowM.CallPrimitive (Primitive.StateRead mutable) LowM.Pure + | Pointer.Mutable mutable => call_primitive (Primitive.StateRead mutable) end. - Parameter get_field : Value.t -> string -> M. + Definition get_field (value : Value.t) (field : string) : M := + let- obj := get_object value in + match Dict.read obj.(Object.fields) field with + | Some value => pure value + | None => impossible + end. (** For the `x[i]` syntax. *) - Parameter get_subscript : Value.t -> Value.t -> M. + Definition get_subscript (value : Value.t) (key : Value.t) : M := + let* __getitem__ := get_field value "__getitem__" in + call __getitem__ (make_tuple [key]) (make_dict []). Parameter slice : Value.t -> Value.t -> Value.t -> Value.t -> M. - Parameter get_name : string -> string -> M. + Fixpoint get_name_in_locals_stack + (locals_stack : list Locals.t) + (name : string) : + LowM.t (option Value.t) := + match locals_stack with + | [] => LowM.Pure None + | locals :: locals_stack => + let- locals_object := call_primitive (Primitive.StateRead locals) in + match Dict.read locals_object.(Object.fields) name with + | Some value => LowM.Pure (Some value) + | None => get_name_in_locals_stack locals_stack name + end + end. + + Definition get_name (globals : Globals.t) (locals_stack : list Locals.t) (name : string) : M := + let- value_in_locals_stack := get_name_in_locals_stack locals_stack name in + match value_in_locals_stack with + | Some value => pure value + | None => + let- value := call_primitive (Primitive.GetInGlobals globals name) in + pure value + end. + + Fixpoint fields_of_args (args_values : list Value.t) (arg_names : list string) : Dict.t Value.t := + match args_values, arg_names with + | value :: args_values, name :: arg_names => + Dict.write (fields_of_args args_values arg_names) name value + | _, _ => [] + end. - Parameter set_locals : Value.t -> Value.t -> list string -> M. + Definition create_locals + (locals_stack : list Locals.t) + (args kwargs : Value.t) + (arg_names : list string) : + LowM.t (list Locals.t) := + let- args_object := get_object args in + let- args_values := + match args_object.(Object.internal) with + | Some (Data.List arg_values) => LowM.Pure arg_values + | _ => LowM.Impossible + end in + let- new_locals := call_primitive (Primitive.StateAlloc {| + Object.internal := None; + Object.fields := fields_of_args args_values arg_names; + |}) in + LowM.Pure (new_locals :: locals_stack). Parameter assign : Value.t -> Value.t -> M. @@ -207,8 +322,6 @@ Module M. Parameter assert : Value.t -> M. - Parameter impossible : M. - Parameter if_then_else : Value.t -> M -> M -> M. Parameter for_ : Value.t -> Value.t -> M -> M -> M. @@ -221,7 +334,7 @@ Module M. Ltac monadic e := lazymatch e with | context ctxt [let v : _ := ?x in @?f v] => - refine (let_ _ _); + refine (bind _ _); [ monadic x | let v' := fresh v in intro v'; @@ -229,7 +342,7 @@ Module M. lazymatch context ctxt [let v := x in y] with | let _ := x in y => monadic y | _ => - refine (let_ _ _); + refine (bind _ _); [ monadic y | let w := fresh "v" in intro w; @@ -242,7 +355,7 @@ Module M. lazymatch context ctxt [run x] with | run x => monadic x | _ => - refine (let_ _ _); + refine (bind _ _); [ monadic x | let v := fresh "v" in intro v; @@ -330,68 +443,26 @@ End Compare. (** ** Builtins *) Module builtins. - Definition globals : string := "builtins". - Definition make_klass (bases : list (string * string)) (class_methods : list (string * (Value.t -> Value.t -> M))) (methods : list (string * (Value.t -> Value.t -> M))) : Value.t := - Value.Make builtins.globals "type" (Pointer.Imm (Object.wrapper ( + Value.Make "builtins" "type" (Pointer.Imm (Object.wrapper ( Data.Klass bases class_methods methods ))). Definition type : Value.t := make_klass [] [] []. - Axiom type_in_globals : IsInGlobals globals type "type". + Axiom type_in_globals : IsInGlobals "builtins" type "type". Definition int : Value.t := make_klass [] [] []. - Axiom int_in_globals : IsInGlobals globals int "int". + Axiom int_in_globals : IsInGlobals "builtins" int "int". Definition str : Value.t := make_klass [] [] []. - Axiom str_in_globals : IsInGlobals globals str "str". + Axiom str_in_globals : IsInGlobals "builtins" str "str". End builtins. -Module Constant. - Definition None_ : Value.t := - Value.Make builtins.globals "NoneType" (Pointer.Imm {| - Object.internal := None; - Object.fields := []; - |}). - - Definition ellipsis : Value.t := - Value.Make builtins.globals "ellipsis" (Pointer.Imm (Object.wrapper Data.Ellipsis)). - - Definition bool (b : bool) : Value.t := - Value.Make builtins.globals "bool" (Pointer.Imm (Object.wrapper (Data.Bool b))). - - Definition int (z : Z) : Value.t := - Value.Make builtins.globals "int" (Pointer.Imm (Object.wrapper (Data.Integer z))). - - Definition float (f : string) : Value.t := - Value.Make builtins.globals "float" (Pointer.Imm (Object.wrapper (Data.Float f))). - - Definition str (s : string) : Value.t := - Value.Make builtins.globals "str" (Pointer.Imm (Object.wrapper (Data.String s))). - - Definition bytes (b : string) : Value.t := - Value.Make builtins.globals "bytes" (Pointer.Imm (Object.wrapper (Data.String b))). -End Constant. - -Definition make_tuple (items : list Value.t) : Value.t := - Value.Make builtins.globals "tuple" (Pointer.Imm (Object.wrapper (Data.Tuple items))). - -Definition make_list (items : list Value.t) : Value.t := - Value.Make builtins.globals "list" (Pointer.Imm (Object.wrapper (Data.List items))). - Parameter make_list_concat : list Value.t -> M. - -Definition make_set (items : list Value.t) : Value.t := - Value.Make builtins.globals "set" (Pointer.Imm (Object.wrapper (Data.Set_ items))). - -Parameter order_dict : list (string * Value.t) -> list (string * Value.t). - -Definition make_dict (dict : list (string * Value.t)) : Value.t := - Value.Make builtins.globals "dict" (Pointer.Imm (Object.wrapper (Data.Dict (order_dict dict)))). diff --git a/CoqOfPython/ethereum/__init__.v b/CoqOfPython/ethereum/__init__.v index e1c92c1..3994534 100644 --- a/CoqOfPython/ethereum/__init__.v +++ b/CoqOfPython/ethereum/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.__init__". +Definition globals : Globals.t := "ethereum.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,14 +39,14 @@ Definition EVM_RECURSION_LIMIT : Value.t := M.run ltac:(M.monadic ( Definition expr_27 : Value.t := M.call (| - M.get_field (| M.get_name (| globals, "sys" |), "setrecursionlimit" |), + M.get_field (| M.get_name (| globals, locals_stack, "sys" |), "setrecursionlimit" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "EVM_RECURSION_LIMIT" |); + M.get_name (| globals, locals_stack, "EVM_RECURSION_LIMIT" |); M.call (| - M.get_field (| M.get_name (| globals, "sys" |), "getrecursionlimit" |), + M.get_field (| M.get_name (| globals, locals_stack, "sys" |), "getrecursionlimit" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/__init__.v b/CoqOfPython/ethereum/arrow_glacier/__init__.v index 6adb453..70f81b6 100644 --- a/CoqOfPython/ethereum/arrow_glacier/__init__.v +++ b/CoqOfPython/ethereum/arrow_glacier/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.__init__". +Definition globals : Globals.t := "ethereum.arrow_glacier.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -13,7 +15,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 13773000 ], diff --git a/CoqOfPython/ethereum/arrow_glacier/blocks.v b/CoqOfPython/ethereum/arrow_glacier/blocks.v index 09a6083..7e91936 100644 --- a/CoqOfPython/ethereum/arrow_glacier/blocks.v +++ b/CoqOfPython/ethereum/arrow_glacier/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.blocks". +Definition globals : Globals.t := "ethereum.arrow_glacier.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/arrow_glacier/bloom.v b/CoqOfPython/ethereum/arrow_glacier/bloom.v index 9f27d32..128d38b 100644 --- a/CoqOfPython/ethereum/arrow_glacier/bloom.v +++ b/CoqOfPython/ethereum/arrow_glacier/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.bloom". +Definition globals : Globals.t := "ethereum.arrow_glacier.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_arrow_glacier_fork_types_imports_Bloom : IsImported globals "ethereum.arrow_glacier.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/fork.v b/CoqOfPython/ethereum/arrow_glacier/fork.v index 00cdb50..c7458cf 100644 --- a/CoqOfPython/ethereum/arrow_glacier/fork.v +++ b/CoqOfPython/ethereum/arrow_glacier/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.fork". +Definition globals : Globals.t := "ethereum.arrow_glacier.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -150,7 +152,7 @@ Axiom ethereum_arrow_glacier_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -182,7 +184,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -200,10 +202,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -225,8 +227,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -246,13 +249,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -275,7 +279,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -286,9 +290,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -310,17 +314,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -333,13 +337,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -350,20 +354,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -388,112 +393,112 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "base_fee_per_gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "base_fee_per_gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -502,9 +507,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -513,9 +518,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -529,8 +534,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the base fee per gas for the block. @@ -553,22 +559,22 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_gas_target" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "ELASTICITY_MULTIPLIER" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "ELASTICITY_MULTIPLIER" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_name (| globals, "block_gas_limit" |); - M.get_name (| globals, "parent_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |); + M.get_name (| globals, locals_stack, "parent_gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -576,14 +582,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "expected_base_fee_per_gas" , - M.get_name (| globals, "parent_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |) |) in M.pure Constant.None_ (* else *) @@ -592,40 +598,40 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |); Constant.int 1 ], @@ -635,8 +641,8 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.add (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -645,36 +651,36 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_target" |), - M.get_name (| globals, "parent_gas_used" |) + M.get_name (| globals, locals_stack, "parent_gas_target" |), + M.get_name (| globals, locals_stack, "parent_gas_used" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.sub (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -683,9 +689,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "expected_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |) ], make_dict [] |) @@ -693,8 +699,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -713,123 +720,123 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |), - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , M.call (| - M.get_name (| globals, "calculate_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "calculate_base_fee_per_gas" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "base_fee_per_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "expected_base_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -838,28 +845,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -885,27 +893,27 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |); - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -913,8 +921,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -932,9 +941,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -942,25 +951,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -969,41 +978,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -1031,23 +1041,23 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1056,46 +1066,46 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "priority_fee_per_gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) ], make_dict [] @@ -1104,38 +1114,39 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_price" , BinOp.add (| - M.get_name (| globals, "priority_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_price" , - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ] |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -1159,7 +1170,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -1168,10 +1179,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -1181,9 +1192,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1196,10 +1207,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1209,9 +1220,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1221,7 +1232,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -1240,8 +1251,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -1286,22 +1298,22 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1310,16 +1322,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1327,9 +1339,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1337,14 +1349,14 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ], M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "base_fee_per_gas" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -1352,18 +1364,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1371,49 +1383,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1422,56 +1434,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1482,8 +1494,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1508,27 +1521,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1537,9 +1550,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1557,46 +1570,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1607,19 +1620,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1628,23 +1641,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1652,16 +1665,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1675,13 +1688,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1696,11 +1709,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1708,88 +1721,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1802,8 +1815,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1832,44 +1846,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1881,19 +1895,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1906,8 +1920,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1935,30 +1950,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1967,10 +1982,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1979,8 +1994,8 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |) |) |) in M.pure Constant.None_ @@ -1989,100 +2004,100 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "max_gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "max_gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "effective_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "effective_gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2090,7 +2105,7 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2099,10 +2114,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2110,25 +2125,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -2152,14 +2167,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2167,10 +2182,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2178,20 +2193,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 5 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -2200,17 +2215,17 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "priority_fee_per_gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |), - M.get_field (| M.get_name (| globals, "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| @@ -2218,41 +2233,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_name (| globals, "priority_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -2260,31 +2275,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -2295,20 +2310,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -2321,14 +2336,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2340,27 +2355,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2376,13 +2391,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -2411,17 +2427,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -2436,8 +2452,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -2466,14 +2483,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2481,7 +2498,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2489,7 +2506,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2503,9 +2520,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2516,7 +2533,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2535,10 +2552,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2546,26 +2563,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -2581,17 +2598,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -2600,8 +2617,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2624,47 +2642,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2672,10 +2690,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2683,19 +2701,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2705,18 +2723,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2728,58 +2746,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2796,10 +2814,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2808,15 +2826,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2831,10 +2849,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2843,15 +2861,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_1559" |), + M.get_name (| globals, locals_stack, "signing_hash_1559" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2870,13 +2888,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2891,8 +2909,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2908,12 +2927,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2924,8 +2943,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2943,19 +2963,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2971,8 +2991,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -2988,14 +3009,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -3007,8 +3028,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_1559 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 1559 signature. @@ -3024,14 +3046,14 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -3043,8 +3065,9 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -3078,12 +3101,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -3094,8 +3117,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -3126,18 +3150,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3154,10 +3178,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3174,8 +3198,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -3193,8 +3217,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -3238,21 +3263,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -3262,11 +3287,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -3284,13 +3309,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -3299,13 +3324,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -3316,7 +3341,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -3326,7 +3351,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -3336,13 +3361,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/fork_types.v b/CoqOfPython/ethereum/arrow_glacier/fork_types.v index e46e8cb..d1223e7 100644 --- a/CoqOfPython/ethereum/arrow_glacier/fork_types.v +++ b/CoqOfPython/ethereum/arrow_glacier/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.fork_types". +Definition globals : Globals.t := "ethereum.arrow_glacier.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/arrow_glacier/state.v b/CoqOfPython/ethereum/arrow_glacier/state.v index 455bfaa..a0b8e6e 100644 --- a/CoqOfPython/ethereum/arrow_glacier/state.v +++ b/CoqOfPython/ethereum/arrow_glacier/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.state". +Definition globals : Globals.t := "ethereum.arrow_glacier.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1163,19 +1191,20 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1194,14 +1223,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,18 +1243,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1234,7 +1263,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1242,7 +1271,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1255,10 +1284,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1266,14 +1295,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/transactions.v b/CoqOfPython/ethereum/arrow_glacier/transactions.v index 67ba8e4..ab24a7f 100644 --- a/CoqOfPython/ethereum/arrow_glacier/transactions.v +++ b/CoqOfPython/ethereum/arrow_glacier/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.transactions". +Definition globals : Globals.t := "ethereum.arrow_glacier.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,14 +99,15 @@ Definition FeeMarketTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -112,17 +115,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -131,10 +134,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -144,9 +147,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -159,10 +162,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -172,9 +175,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -184,7 +187,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -199,8 +202,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -208,10 +212,10 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), @@ -222,7 +226,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 @@ -231,11 +235,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -252,7 +256,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 2 @@ -261,11 +265,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "FeeMarketTransaction" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -277,7 +281,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ @@ -286,7 +290,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/arrow_glacier/trie.v b/CoqOfPython/ethereum/arrow_glacier/trie.v index 0941ddc..a607f38 100644 --- a/CoqOfPython/ethereum/arrow_glacier/trie.v +++ b/CoqOfPython/ethereum/arrow_glacier/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.trie". +Definition globals : Globals.t := "ethereum.arrow_glacier.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_arrow_glacier_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,34 +124,34 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -187,14 +189,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -218,7 +221,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -234,10 +237,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -246,13 +249,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -261,10 +264,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -273,13 +276,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -288,10 +291,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -300,9 +303,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -310,7 +313,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -327,9 +330,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -339,9 +342,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -350,16 +353,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -369,8 +372,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -380,25 +384,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -410,10 +414,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -421,13 +425,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -442,27 +446,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -486,8 +490,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -504,14 +509,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -522,8 +527,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -543,8 +549,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -552,14 +558,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -571,18 +577,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -602,10 +609,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -613,21 +620,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -640,11 +648,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -652,12 +660,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -665,7 +673,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -680,9 +688,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -690,8 +698,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -728,7 +737,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -739,9 +748,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -752,13 +761,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -766,15 +775,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -784,20 +793,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -815,7 +824,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -823,13 +832,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -838,15 +847,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -856,20 +865,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -887,9 +896,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -897,8 +906,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -915,14 +925,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -933,26 +943,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -960,17 +970,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -982,9 +992,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -992,8 +1002,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1014,9 +1025,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1025,25 +1036,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1051,13 +1062,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1071,9 +1082,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1081,13 +1092,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1095,15 +1106,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1113,22 +1124,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1137,13 +1148,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1164,10 +1176,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1175,14 +1187,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1200,12 +1212,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1218,12 +1230,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1235,18 +1247,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1256,8 +1268,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1281,9 +1294,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1302,12 +1315,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1320,9 +1333,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1333,24 +1346,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1360,8 +1373,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1369,31 +1382,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1408,7 +1421,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1429,7 +1442,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1437,30 +1450,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1480,9 +1493,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1490,7 +1503,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1508,21 +1521,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1530,19 +1543,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1551,8 +1564,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1561,17 +1574,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1584,10 +1597,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/utils/__init__.v b/CoqOfPython/ethereum/arrow_glacier/utils/__init__.v index 15ee17f..67b99d9 100644 --- a/CoqOfPython/ethereum/arrow_glacier/utils/__init__.v +++ b/CoqOfPython/ethereum/arrow_glacier/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.utils.__init__". +Definition globals : Globals.t := "ethereum.arrow_glacier.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/arrow_glacier/utils/address.v b/CoqOfPython/ethereum/arrow_glacier/utils/address.v index 34dfc3f..a702f3e 100644 --- a/CoqOfPython/ethereum/arrow_glacier/utils/address.v +++ b/CoqOfPython/ethereum/arrow_glacier/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.utils.address". +Definition globals : Globals.t := "ethereum.arrow_glacier.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_arrow_glacier_fork_types_imports_Address : IsImported globals "ethereum.arrow_glacier.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/utils/hexadecimal.v b/CoqOfPython/ethereum/arrow_glacier/utils/hexadecimal.v index 7d39659..ff8431f 100644 --- a/CoqOfPython/ethereum/arrow_glacier/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/arrow_glacier/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.arrow_glacier.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_arrow_glacier_fork_types_imports_Root : IsImported globals "ethereum.arrow_glacier.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/arrow_glacier/utils/message.v b/CoqOfPython/ethereum/arrow_glacier/utils/message.v index c8a6555..f3cf69e 100644 --- a/CoqOfPython/ethereum/arrow_glacier/utils/message.v +++ b/CoqOfPython/ethereum/arrow_glacier/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.utils.message". +Definition globals : Globals.t := "ethereum.arrow_glacier.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_arrow_glacier_utils_address_imports_compute_contract_address : IsImported globals "ethereum.arrow_glacier.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/__init__.v b/CoqOfPython/ethereum/arrow_glacier/vm/__init__.v index 19418af..07ef173 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/__init__.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.__init__". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,8 +99,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -111,30 +114,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -142,19 +145,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,24 +167,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -196,15 +200,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -217,8 +221,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -226,19 +230,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -254,7 +258,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/exceptions.v b/CoqOfPython/ethereum/arrow_glacier/vm/exceptions.v index c699641..ed3e40a 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/exceptions.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.exceptions". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/gas.v b/CoqOfPython/ethereum/arrow_glacier/vm/gas.v index ca2cac0..49e4e06 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/gas.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.gas". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_arrow_glacier_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -86,7 +88,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 4800 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -116,7 +118,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -126,7 +128,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -136,7 +138,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -166,7 +168,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -176,7 +178,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -196,7 +198,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -206,7 +208,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -216,7 +218,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -226,7 +228,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -236,7 +238,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -246,7 +248,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -256,7 +258,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -266,7 +268,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -276,7 +278,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -286,7 +288,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -296,7 +298,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -306,7 +308,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -326,7 +328,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -336,7 +338,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -346,7 +348,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -356,7 +358,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -366,7 +368,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -376,7 +378,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -386,7 +388,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -396,7 +398,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -406,7 +408,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -416,7 +418,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -426,7 +428,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -436,7 +438,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -465,8 +467,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -479,13 +482,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -496,22 +499,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -521,8 +524,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -542,9 +546,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -554,15 +558,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -571,16 +575,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,12 +624,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -634,14 +639,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -655,9 +660,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -665,20 +670,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -691,8 +696,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -706,16 +711,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -723,9 +728,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -734,13 +739,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -750,10 +755,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -761,8 +766,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -793,13 +799,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -807,32 +813,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -846,18 +852,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -868,15 +874,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -885,8 +891,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -902,9 +909,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/__init__.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/__init__.v index 2163ec5..1309d4b 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/arithmetic.v index 9c026ce..9597ba5 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/bitwise.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/bitwise.v index db4eddd..c847f7a 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/block.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/block.v index b5df822..1a1ef12 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/block.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.block". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,14 +350,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -361,21 +370,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -384,7 +393,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/comparison.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/comparison.v index a48a324..908a3d2 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/control_flow.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/control_flow.v index ab3b78d..5ddb601 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/environment.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/environment.v index 182c5e4..df5ed9f 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -149,16 +153,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -166,17 +170,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -185,32 +189,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -223,21 +228,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -246,14 +251,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -265,21 +271,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -288,14 +294,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -307,31 +314,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -345,30 +353,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -379,13 +387,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -394,14 +402,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -413,24 +422,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -442,14 +451,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -465,9 +475,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -475,9 +485,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -485,9 +495,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -496,12 +506,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -514,76 +524,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -595,24 +606,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -624,14 +635,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -647,9 +659,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -657,9 +669,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -667,9 +679,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,12 +690,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -696,76 +708,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -777,21 +790,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -800,14 +813,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -820,12 +834,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -837,16 +851,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -854,17 +868,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -873,16 +887,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -894,23 +908,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -923,12 +938,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -939,9 +954,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -949,9 +964,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -959,9 +974,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -970,12 +985,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -988,18 +1003,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1009,21 +1024,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1032,22 +1047,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1056,19 +1071,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1076,34 +1091,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1114,24 +1130,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1143,14 +1159,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1162,9 +1179,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1172,9 +1189,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1182,9 +1199,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1193,12 +1210,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1211,108 +1228,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1323,12 +1341,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1340,16 +1358,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1357,17 +1375,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1376,10 +1394,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1388,15 +1406,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1409,12 +1427,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1425,23 +1443,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1453,42 +1472,43 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the base fee of the current block on to the stack. @@ -1500,21 +1520,21 @@ Definition base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "base_fee_per_gas" |) ], make_dict [] |) @@ -1523,7 +1543,7 @@ Definition base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/keccak.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/keccak.v index eea02f8..1f22c7b 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/log.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/log.v index 77cb339..2011aea 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/log.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.log". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_pop : IsImported globals "ethereum.arrow_glacier.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/memory.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/memory.v index 4fdbe0d..2b19411 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/stack.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/stack.v index ba06637..6b754e3 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_arrow_glacier_vm_memory_imports_buffer_read : IsImported globals "ethereum.arrow_glacier.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/storage.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/storage.v index b104e43..04a8c7a 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -59,8 +61,9 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -75,9 +78,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -89,16 +92,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -106,17 +109,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -125,33 +128,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -165,9 +169,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -178,32 +182,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -211,11 +215,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -223,7 +227,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -234,22 +238,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -261,13 +265,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -277,7 +281,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -285,7 +289,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -294,8 +298,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -306,7 +310,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -314,8 +318,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -324,18 +328,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -346,11 +350,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -365,12 +369,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -379,11 +383,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -397,8 +401,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -406,20 +410,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -430,16 +434,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -458,34 +462,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/system.v b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/system.v index 315f8d0..642da72 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/instructions/system.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.instructions.system". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,28 +107,29 @@ Axiom ethereum_arrow_glacier_vm_stack_imports_push : IsImported globals "ethereum.arrow_glacier.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -136,32 +139,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -171,15 +174,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -195,10 +198,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -208,15 +211,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -237,29 +240,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -279,27 +282,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -307,10 +310,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -318,27 +321,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,25 +354,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -381,8 +384,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -394,9 +398,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -404,9 +408,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -414,9 +418,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -424,46 +428,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -472,26 +476,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -506,9 +511,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -516,9 +521,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -526,9 +531,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -537,9 +542,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -550,11 +555,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -564,12 +569,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -580,43 +585,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -625,26 +630,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -656,9 +662,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -666,9 +672,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -676,63 +682,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -740,24 +747,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -777,11 +784,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -789,10 +796,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -800,7 +807,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -808,10 +815,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -819,27 +826,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -852,23 +859,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -882,16 +889,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -903,14 +910,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -919,8 +926,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -932,12 +940,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -948,12 +956,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -964,9 +972,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -974,9 +982,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -984,9 +992,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -994,9 +1002,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1004,9 +1012,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1014,12 +1022,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1029,28 +1037,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1060,16 +1068,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1077,7 +1085,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1085,7 +1093,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1093,13 +1101,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1107,56 +1115,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1165,25 +1173,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1192,17 +1200,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1212,32 +1220,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1245,14 +1253,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1264,12 +1273,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,12 +1289,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1296,9 +1305,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,9 +1315,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1316,9 +1325,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1326,9 +1335,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1336,26 +1345,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1365,28 +1374,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1395,13 +1404,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1409,58 +1418,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1469,17 +1478,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1489,32 +1498,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1522,14 +1531,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1541,12 +1551,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1556,28 +1566,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1589,20 +1599,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1615,7 +1625,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1623,32 +1633,32 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1656,33 +1666,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1692,9 +1702,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1702,19 +1712,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1724,15 +1734,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1744,12 +1755,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1760,12 +1771,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,9 +1787,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1786,9 +1797,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1796,9 +1807,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1806,9 +1817,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1816,12 +1827,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1831,104 +1842,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1940,12 +1952,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1956,12 +1968,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1972,9 +1984,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1982,9 +1994,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1992,9 +2004,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2002,9 +2014,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2012,12 +2024,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2027,110 +2039,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2142,9 +2155,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2152,9 +2165,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2162,54 +2175,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/interpreter.v b/CoqOfPython/ethereum/arrow_glacier/vm/interpreter.v index 7958dd7..c82ea50 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/interpreter.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.interpreter". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -126,7 +128,7 @@ Axiom ethereum_arrow_glacier_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -149,8 +151,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -172,9 +175,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -186,10 +189,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -197,44 +200,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -248,10 +251,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -264,10 +267,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -276,13 +279,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -292,12 +295,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -314,14 +317,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -329,7 +332,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -337,7 +340,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -349,22 +352,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -374,29 +377,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -404,8 +407,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -422,43 +426,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -466,24 +470,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -491,22 +495,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -526,13 +531,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -544,17 +549,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -562,10 +567,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -573,12 +578,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -590,10 +595,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -601,13 +606,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -615,22 +620,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -648,14 +654,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -663,13 +669,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/memory.v b/CoqOfPython/ethereum/arrow_glacier/vm/memory.v index 207f7fb..4e18aa3 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/memory.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.memory". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/__init__.v index 2d091ab..51c0478 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/alt_bn128.v index 4649b5a..401bbbb 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_arrow_glacier_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.arrow_glacier.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/blake2f.v index 0cad2c6..1c0b95b 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_arrow_glacier_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.arrow_glacier.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ecrecover.v index aaa3942..287fab3 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_arrow_glacier_vm_memory_imports_buffer_read : IsImported globals "ethereum.arrow_glacier.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/identity.v index 7443148..5934829 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_arrow_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.arrow_glacier.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/mapping.v index d47d1fc..a762493 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/modexp.v index df32505..9fae72b 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ripemd160.v index cc2bc0a..bdaeafd 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_arrow_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.arrow_glacier.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/sha256.v index ce66ace..d0c1ce0 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_arrow_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.arrow_glacier.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/runtime.v b/CoqOfPython/ethereum/arrow_glacier/vm/runtime.v index 4e59678..b2c3715 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/runtime.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.runtime". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_arrow_glacier_vm_instructions_imports_Ops : IsImported globals "ethereum.arrow_glacier.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/arrow_glacier/vm/stack.v b/CoqOfPython/ethereum/arrow_glacier/vm/stack.v index 9258f93..815fc8e 100644 --- a/CoqOfPython/ethereum/arrow_glacier/vm/stack.v +++ b/CoqOfPython/ethereum/arrow_glacier/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.arrow_glacier.vm.stack". +Definition globals : Globals.t := "ethereum.arrow_glacier.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_arrow_glacier_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.arrow_glacier.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/base_types.v b/CoqOfPython/ethereum/base_types.v index 4229846..bf2b870 100644 --- a/CoqOfPython/ethereum/base_types.v +++ b/CoqOfPython/ethereum/base_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.base_types". +Definition globals : Globals.t := "ethereum.base_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -95,20 +97,21 @@ Definition Uint : Value.t := [ ( "from_be_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into an arbitrarily sized unsigned integer from its big endian representation. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "big" ], make_dict [] @@ -121,20 +124,21 @@ Definition Uint : Value.t := ); ( "from_le_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into an arbitrarily sized unsigned integer from its little endian representation. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "little" ], make_dict [] @@ -149,23 +153,24 @@ Definition Uint : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "value" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "TypeError" |), + M.get_name (| globals, locals_stack, "TypeError" |), make_list [], make_dict [] |)) |) in @@ -178,13 +183,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -197,13 +202,14 @@ Definition Uint : Value.t := ); ( "__radd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -212,23 +218,24 @@ Definition Uint : Value.t := ); ( "__add__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -239,13 +246,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -256,14 +263,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__add__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -275,13 +282,14 @@ Definition Uint : Value.t := ); ( "__iadd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -290,23 +298,24 @@ Definition Uint : Value.t := ); ( "__sub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -318,20 +327,20 @@ Definition Uint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "right" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -342,14 +351,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__sub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__sub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -361,23 +370,24 @@ Definition Uint : Value.t := ); ( "__rsub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -389,20 +399,20 @@ Definition Uint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "left" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -413,14 +423,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rsub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rsub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -432,13 +442,14 @@ Definition Uint : Value.t := ); ( "__isub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__sub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__sub__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -447,23 +458,24 @@ Definition Uint : Value.t := ); ( "__mul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -474,13 +486,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -491,14 +503,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__mul__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -510,13 +522,14 @@ Definition Uint : Value.t := ); ( "__rmul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -525,13 +538,14 @@ Definition Uint : Value.t := ); ( "__imul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -540,23 +554,24 @@ Definition Uint : Value.t := ); ( "__floordiv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -567,13 +582,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -584,14 +599,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__floordiv__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__floordiv__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -603,23 +618,24 @@ Definition Uint : Value.t := ); ( "__rfloordiv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -630,13 +646,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -647,14 +663,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rfloordiv__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rfloordiv__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -666,13 +682,14 @@ Definition Uint : Value.t := ); ( "__ifloordiv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__floordiv__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__floordiv__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -681,23 +698,24 @@ Definition Uint : Value.t := ); ( "__mod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -708,13 +726,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -725,14 +743,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__mod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__mod__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -744,23 +762,24 @@ Definition Uint : Value.t := ); ( "__rmod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -771,13 +790,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -788,14 +807,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rmod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rmod__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -807,13 +826,14 @@ Definition Uint : Value.t := ); ( "__imod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mod__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -822,23 +842,24 @@ Definition Uint : Value.t := ); ( "__divmod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -849,13 +870,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -867,31 +888,31 @@ Definition Uint : Value.t := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__divmod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__divmod__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) |) in let _ := M.return_ (| make_tuple [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 0 |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 1 |) ], @@ -902,23 +923,24 @@ Definition Uint : Value.t := ); ( "__rdivmod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -929,13 +951,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -947,31 +969,31 @@ Definition Uint : Value.t := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rdivmod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rdivmod__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) |) in let _ := M.return_ (| make_tuple [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 0 |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 1 |) ], @@ -982,13 +1004,14 @@ Definition Uint : Value.t := ); ( "__pow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right"; "modulo" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.is_not (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.None_ |), (* then *) @@ -997,17 +1020,17 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "modulo" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "modulo" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1018,13 +1041,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1042,17 +1065,17 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1063,13 +1086,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1080,15 +1103,15 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__pow__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |) @@ -1100,13 +1123,14 @@ Definition Uint : Value.t := ); ( "__rpow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left"; "modulo" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.is_not (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.None_ |), (* then *) @@ -1115,17 +1139,17 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "modulo" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "modulo" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1136,13 +1160,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1160,17 +1184,17 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1181,13 +1205,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1198,15 +1222,15 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rpow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rpow__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |) @@ -1218,14 +1242,15 @@ Definition Uint : Value.t := ); ( "__ipow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right"; "modulo" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__pow__" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |) @@ -1234,23 +1259,24 @@ Definition Uint : Value.t := ); ( "__xor__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1261,13 +1287,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1278,14 +1304,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__xor__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__xor__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -1297,23 +1323,24 @@ Definition Uint : Value.t := ); ( "__rxor__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1324,13 +1351,13 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1341,14 +1368,14 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rxor__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rxor__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -1360,13 +1387,14 @@ Definition Uint : Value.t := ); ( "__ixor__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__xor__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__xor__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -1375,18 +1403,19 @@ Definition Uint : Value.t := ); ( "to_be_bytes32", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this arbitrarily sized unsigned integer into its big endian representation with exactly 32 bytes. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes32" |), + M.get_name (| globals, locals_stack, "Bytes32" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ Constant.int 32; Constant.str "big" @@ -1401,8 +1430,9 @@ Definition Uint : Value.t := ); ( "to_be_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this arbitrarily sized unsigned integer into its big endian representation, without padding. @@ -1410,7 +1440,7 @@ Definition Uint : Value.t := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "bit_length" |), make_list [], make_dict [] |) @@ -1419,7 +1449,7 @@ Definition Uint : Value.t := "byte_length" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 7 |), Constant.int 8 @@ -1427,9 +1457,9 @@ Definition Uint : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ - M.get_name (| globals, "byte_length" |); + M.get_name (| globals, locals_stack, "byte_length" |); Constant.str "big" ], make_dict [] @@ -1439,8 +1469,9 @@ Definition Uint : Value.t := ); ( "to_le_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "number_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "number_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this arbitrarily sized unsigned integer into its little endian representation, without padding. @@ -1449,7 +1480,7 @@ Definition Uint : Value.t := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "number_bytes" |), + M.get_name (| globals, locals_stack, "number_bytes" |), Constant.None_ |), (* then *) @@ -1457,7 +1488,7 @@ Definition Uint : Value.t := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "bit_length" |), make_list [], make_dict [] |) @@ -1466,7 +1497,7 @@ Definition Uint : Value.t := "number_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 7 |), Constant.int 8 @@ -1479,9 +1510,9 @@ Definition Uint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ - M.get_name (| globals, "number_bytes" |); + M.get_name (| globals, locals_stack, "number_bytes" |); Constant.str "little" ], make_dict [] @@ -1493,7 +1524,7 @@ Definition Uint : Value.t := Definition T : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "T" ], @@ -1510,23 +1541,24 @@ Definition FixedUint : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "value" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "TypeError" |), + M.get_name (| globals, locals_stack, "TypeError" |), make_list [], make_dict [] |)) |) in @@ -1540,20 +1572,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1566,13 +1598,14 @@ Definition FixedUint : Value.t := ); ( "__radd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -1581,23 +1614,24 @@ Definition FixedUint : Value.t := ); ( "__add__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1607,10 +1641,10 @@ Definition FixedUint : Value.t := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__add__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -1620,20 +1654,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "result" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "result" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1644,10 +1678,10 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) @@ -1656,8 +1690,9 @@ Definition FixedUint : Value.t := ); ( "wrapping_add", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.str " Return a new instance containing `self + right (mod N)`. @@ -1671,17 +1706,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1693,20 +1728,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1717,19 +1752,19 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__add__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) ], make_dict [] @@ -1739,13 +1774,14 @@ Definition FixedUint : Value.t := ); ( "__iadd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -1754,23 +1790,24 @@ Definition FixedUint : Value.t := ); ( "__sub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1782,19 +1819,19 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.or (| Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "right" |) |) )) |) @@ -1803,7 +1840,7 @@ Definition FixedUint : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1814,14 +1851,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__sub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__sub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -1833,8 +1870,9 @@ Definition FixedUint : Value.t := ); ( "wrapping_sub", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.str " Return a new instance containing `self - right (mod N)`. @@ -1848,17 +1886,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1870,20 +1908,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1894,19 +1932,19 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__sub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__sub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) ], make_dict [] @@ -1916,23 +1954,24 @@ Definition FixedUint : Value.t := ); ( "__rsub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1944,19 +1983,19 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.or (| Compare.gt (| - M.get_name (| globals, "left" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "left" |) |) )) |) @@ -1965,7 +2004,7 @@ Definition FixedUint : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -1976,14 +2015,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rsub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rsub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -1995,13 +2034,14 @@ Definition FixedUint : Value.t := ); ( "__isub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__sub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__sub__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2010,23 +2050,24 @@ Definition FixedUint : Value.t := ); ( "__mul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2036,10 +2077,10 @@ Definition FixedUint : Value.t := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__mul__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2049,20 +2090,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "result" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "result" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2073,10 +2114,10 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) @@ -2085,8 +2126,9 @@ Definition FixedUint : Value.t := ); ( "wrapping_mul", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.str " Return a new instance containing `self * right (mod N)`. @@ -2100,17 +2142,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2122,20 +2164,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2146,19 +2188,19 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__mul__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) ], make_dict [] @@ -2168,13 +2210,14 @@ Definition FixedUint : Value.t := ); ( "__rmul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -2183,13 +2226,14 @@ Definition FixedUint : Value.t := ); ( "__imul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2198,23 +2242,24 @@ Definition FixedUint : Value.t := ); ( "__floordiv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2226,20 +2271,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2250,14 +2295,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__floordiv__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__floordiv__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2269,23 +2314,24 @@ Definition FixedUint : Value.t := ); ( "__rfloordiv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2297,20 +2343,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "left" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2321,14 +2367,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rfloordiv__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rfloordiv__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -2340,13 +2386,14 @@ Definition FixedUint : Value.t := ); ( "__ifloordiv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__floordiv__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__floordiv__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2355,23 +2402,24 @@ Definition FixedUint : Value.t := ); ( "__mod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2383,20 +2431,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2407,14 +2455,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__mod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__mod__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2426,23 +2474,24 @@ Definition FixedUint : Value.t := ); ( "__rmod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2454,20 +2503,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "left" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2478,14 +2527,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rmod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rmod__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -2497,13 +2546,14 @@ Definition FixedUint : Value.t := ); ( "__imod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mod__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mod__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2512,23 +2562,24 @@ Definition FixedUint : Value.t := ); ( "__divmod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2540,20 +2591,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2566,36 +2617,36 @@ Definition FixedUint : Value.t := "result" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [ - M.get_name (| globals, "FixedUint" |); - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "FixedUint" |); + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), "__divmod__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) |) in let _ := M.return_ (| make_tuple [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 0 |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 1 |) ], @@ -2606,23 +2657,24 @@ Definition FixedUint : Value.t := ); ( "__rdivmod__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2634,20 +2686,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "left" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2660,36 +2712,36 @@ Definition FixedUint : Value.t := "result" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [ - M.get_name (| globals, "FixedUint" |); - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "FixedUint" |); + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), "__rdivmod__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) |) in let _ := M.return_ (| make_tuple [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 0 |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.get_subscript (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), Constant.int 1 |) ], @@ -2700,13 +2752,14 @@ Definition FixedUint : Value.t := ); ( "__pow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right"; "modulo" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.is_not (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.None_ |), (* then *) @@ -2715,17 +2768,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "modulo" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "modulo" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2737,20 +2790,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "modulo" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "modulo" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2768,17 +2821,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2788,11 +2841,11 @@ Definition FixedUint : Value.t := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__pow__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |) @@ -2802,19 +2855,19 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.or (| Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "result" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "result" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |) @@ -2823,7 +2876,7 @@ Definition FixedUint : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2834,10 +2887,10 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) @@ -2846,8 +2899,9 @@ Definition FixedUint : Value.t := ); ( "wrapping_pow", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right"; "modulo" ] in + ltac:(M.monadic ( let _ := Constant.str " Return a new instance containing `self ** right (mod modulo)`. @@ -2863,7 +2917,7 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| Compare.is_not (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.None_ |), (* then *) @@ -2872,17 +2926,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "modulo" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "modulo" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2894,20 +2948,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "modulo" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "modulo" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2925,17 +2979,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -2947,20 +3001,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -2971,20 +3025,20 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__pow__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) ], make_dict [] @@ -2994,13 +3048,14 @@ Definition FixedUint : Value.t := ); ( "__rpow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left"; "modulo" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.is_not (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.None_ |), (* then *) @@ -3009,17 +3064,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "modulo" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "modulo" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3031,20 +3086,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "modulo" |), + M.get_name (| globals, locals_stack, "modulo" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "modulo" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "modulo" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -3062,17 +3117,17 @@ Definition FixedUint : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3084,20 +3139,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "left" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -3108,15 +3163,15 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rpow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rpow__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |) @@ -3128,14 +3183,15 @@ Definition FixedUint : Value.t := ); ( "__ipow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right"; "modulo" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right"; "modulo" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__pow__" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "modulo" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "modulo" |) ], make_dict [] |) @@ -3144,23 +3200,24 @@ Definition FixedUint : Value.t := ); ( "__and__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3172,20 +3229,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -3196,14 +3253,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__and__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__and__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -3215,23 +3272,24 @@ Definition FixedUint : Value.t := ); ( "__or__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3243,20 +3301,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -3267,14 +3325,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__or__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__or__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -3286,23 +3344,24 @@ Definition FixedUint : Value.t := ); ( "__xor__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3314,20 +3373,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "right" |), + M.get_name (| globals, locals_stack, "right" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "right" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -3338,14 +3397,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__xor__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__xor__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -3357,23 +3416,24 @@ Definition FixedUint : Value.t := ); ( "__rxor__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3385,20 +3445,20 @@ Definition FixedUint : Value.t := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_name (| globals, "left" |), + M.get_name (| globals, locals_stack, "left" |), Constant.int 0 |), ltac:(M.monadic ( Compare.gt (| - M.get_name (| globals, "left" |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "OverflowError" |), + M.get_name (| globals, locals_stack, "OverflowError" |), make_list [], make_dict [] |)) |) in @@ -3409,14 +3469,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rxor__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rxor__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -3428,13 +3488,14 @@ Definition FixedUint : Value.t := ); ( "__ixor__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__xor__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__xor__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -3443,22 +3504,23 @@ Definition FixedUint : Value.t := ); ( "__invert__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__invert__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__invert__" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "self" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MAX_VALUE" |) |) ], make_dict [] @@ -3468,23 +3530,24 @@ Definition FixedUint : Value.t := ); ( "__rshift__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "shift_by" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "shift_by" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "shift_by" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "shift_by" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -3493,14 +3556,14 @@ Definition FixedUint : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "__class__" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__class__" |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rshift__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rshift__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "shift_by" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "shift_by" |) ], make_dict [] |) @@ -3512,8 +3575,9 @@ Definition FixedUint : Value.t := ); ( "to_be_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this unsigned integer into its big endian representation, omitting leading zero bytes. @@ -3521,7 +3585,7 @@ Definition FixedUint : Value.t := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "bit_length" |), make_list [], make_dict [] |) @@ -3530,7 +3594,7 @@ Definition FixedUint : Value.t := "byte_length" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 7 |), Constant.int 8 @@ -3538,9 +3602,9 @@ Definition FixedUint : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ - M.get_name (| globals, "byte_length" |); + M.get_name (| globals, locals_stack, "byte_length" |); Constant.str "big" ], make_dict [] @@ -3556,8 +3620,9 @@ Definition U256 : Value.t := [ ( "from_be_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into a fixed sized unsigned integer from its big endian representation. @@ -3567,9 +3632,9 @@ Definition U256 : Value.t := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "buffer" |) + M.get_name (| globals, locals_stack, "buffer" |) ], make_dict [] |), @@ -3578,7 +3643,7 @@ Definition U256 : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [], make_dict [] |)) |) in @@ -3589,12 +3654,12 @@ Definition U256 : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "big" ], make_dict [] @@ -3607,8 +3672,9 @@ Definition U256 : Value.t := ); ( "from_signed", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates an unsigned integer representing `value` using two's complement. @@ -3617,16 +3683,16 @@ Definition U256 : Value.t := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -3638,11 +3704,11 @@ Definition U256 : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "cls" |), "MAX_VALUE" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "MAX_VALUE" |) |) ], make_dict [] @@ -3654,18 +3720,19 @@ Definition U256 : Value.t := [ ( "to_be_bytes32", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this 256-bit unsigned integer into its big endian representation with exactly 32 bytes. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes32" |), + M.get_name (| globals, locals_stack, "Bytes32" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ Constant.int 32; Constant.str "big" @@ -3680,8 +3747,9 @@ Definition U256 : Value.t := ); ( "to_signed", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Decodes a signed integer from its two's complement representation. " in @@ -3690,7 +3758,7 @@ Definition U256 : Value.t := M.if_then_else (| Compare.lt (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "bit_length" |), make_list [], make_dict [] |), @@ -3700,9 +3768,9 @@ Definition U256 : Value.t := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) @@ -3715,13 +3783,13 @@ Definition U256 : Value.t := let _ := M.return_ (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) |) in M.pure Constant.None_)) @@ -3736,8 +3804,9 @@ Definition U32 : Value.t := [ ( "from_le_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into an arbitrarily sized unsigned integer from its little endian representation. @@ -3747,9 +3816,9 @@ Definition U32 : Value.t := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "buffer" |) + M.get_name (| globals, locals_stack, "buffer" |) ], make_dict [] |), @@ -3758,7 +3827,7 @@ Definition U32 : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [], make_dict [] |)) |) in @@ -3769,12 +3838,12 @@ Definition U32 : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "little" ], make_dict [] @@ -3789,18 +3858,19 @@ Definition U32 : Value.t := [ ( "to_le_bytes4", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this fixed sized unsigned integer into its little endian representation, with exactly 4 bytes. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes4" |), + M.get_name (| globals, locals_stack, "Bytes4" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ Constant.int 4; Constant.str "little" @@ -3815,8 +3885,9 @@ Definition U32 : Value.t := ); ( "to_le_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this fixed sized unsigned integer into its little endian representation, in the fewest bytes possible. @@ -3824,7 +3895,7 @@ Definition U32 : Value.t := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "bit_length" |), make_list [], make_dict [] |) @@ -3833,7 +3904,7 @@ Definition U32 : Value.t := "byte_length" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 7 |), Constant.int 8 @@ -3841,9 +3912,9 @@ Definition U32 : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ - M.get_name (| globals, "byte_length" |); + M.get_name (| globals, locals_stack, "byte_length" |); Constant.str "little" ], make_dict [] @@ -3861,8 +3932,9 @@ Definition U64 : Value.t := [ ( "from_le_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into an arbitrarily sized unsigned integer from its little endian representation. @@ -3872,9 +3944,9 @@ Definition U64 : Value.t := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "buffer" |) + M.get_name (| globals, locals_stack, "buffer" |) ], make_dict [] |), @@ -3883,7 +3955,7 @@ Definition U64 : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [], make_dict [] |)) |) in @@ -3894,12 +3966,12 @@ Definition U64 : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "little" ], make_dict [] @@ -3912,8 +3984,9 @@ Definition U64 : Value.t := ); ( "from_be_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into an unsigned 64 bit integer from its big endian representation. @@ -3923,9 +3996,9 @@ Definition U64 : Value.t := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "buffer" |) + M.get_name (| globals, locals_stack, "buffer" |) ], make_dict [] |), @@ -3934,7 +4007,7 @@ Definition U64 : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [], make_dict [] |)) |) in @@ -3945,12 +4018,12 @@ Definition U64 : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "big" ], make_dict [] @@ -3965,18 +4038,19 @@ Definition U64 : Value.t := [ ( "to_le_bytes8", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this fixed sized unsigned integer into its little endian representation, with exactly 8 bytes. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes8" |), + M.get_name (| globals, locals_stack, "Bytes8" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ Constant.int 8; Constant.str "little" @@ -3991,8 +4065,9 @@ Definition U64 : Value.t := ); ( "to_le_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this fixed sized unsigned integer into its little endian representation, in the fewest bytes possible. @@ -4000,7 +4075,7 @@ Definition U64 : Value.t := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "bit_length" |), make_list [], make_dict [] |) @@ -4009,7 +4084,7 @@ Definition U64 : Value.t := "byte_length" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 7 |), Constant.int 8 @@ -4017,9 +4092,9 @@ Definition U64 : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ - M.get_name (| globals, "byte_length" |); + M.get_name (| globals, locals_stack, "byte_length" |); Constant.str "little" ], make_dict [] @@ -4033,7 +4108,7 @@ Definition U64 : Value.t := Definition B : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "B" ], @@ -4050,8 +4125,9 @@ Definition FixedBytes : Value.t := [ ( "__new__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a new instance, ensuring the result has the correct length. " in @@ -4059,18 +4135,18 @@ Definition FixedBytes : Value.t := "result" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [ - M.get_name (| globals, "FixedBytes" |); - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "FixedBytes" |); + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |), "__new__" |), make_list_concat (| [ make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ]; - M.get_name (| globals, "args" |) + M.get_name (| globals, locals_stack, "args" |) ] |), make_dict [] |) @@ -4080,18 +4156,18 @@ Definition FixedBytes : Value.t := M.if_then_else (| Compare.not_eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "cls" |), "LENGTH" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "LENGTH" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -4103,7 +4179,7 @@ Definition FixedBytes : Value.t := M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) |) in M.pure Constant.None_)) ) @@ -4190,7 +4266,7 @@ Definition Bytes256 : Value.t := ]. Definition Bytes : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "bytes" |) + M.get_name (| globals, locals_stack, "bytes" |) )). Definition expr_925 : Value.t := @@ -4199,15 +4275,16 @@ Sequence of bytes (octets) of arbitrary length. ". Definition _setattr_function : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "attr"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "attr"; "value" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "getattr" |), + M.get_name (| globals, locals_stack, "getattr" |), make_list [ - M.get_name (| globals, "self" |); + M.get_name (| globals, locals_stack, "self" |); Constant.str "_frozen"; Constant.None_ ], @@ -4216,7 +4293,7 @@ Definition _setattr_function : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "Mutating frozen dataclasses is not allowed." ], @@ -4226,11 +4303,11 @@ Definition _setattr_function : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "object" |), "__setattr__" |), + M.get_field (| M.get_name (| globals, locals_stack, "object" |), "__setattr__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "attr" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "attr" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -4239,16 +4316,17 @@ Definition _setattr_function : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _delattr_function : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "attr" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "attr" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "self" |), "_frozen" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_frozen" |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "Mutating frozen dataclasses is not allowed." ], @@ -4258,10 +4336,10 @@ Definition _delattr_function : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "object" |), "__delattr__" |), + M.get_field (| M.get_name (| globals, locals_stack, "object" |), "__delattr__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "attr" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "attr" |) ], make_dict [] |) in @@ -4270,17 +4348,19 @@ Definition _delattr_function : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _make_init_function : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "f" ] in + ltac:(M.monadic ( (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| - M.get_name (| globals, "init_function" |) + M.get_name (| globals, locals_stack, "init_function" |) |) in M.pure Constant.None_)). Definition slotted_freezable : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := Constant.str " Monkey patches a dataclass so it can be frozen by setting `_frozen` to `True` and uses `__slots__` for efficiency. @@ -4289,52 +4369,52 @@ Definition slotted_freezable : Value.t -> Value.t -> M := to `__init__`. " in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "cls" |), "__slots__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__slots__" |), BinOp.add (| make_tuple [ Constant.str "_frozen" ], M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__annotations__" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__annotations__" |) ], make_dict [] |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "cls" |), "__init__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__init__" |), M.call (| - M.get_name (| globals, "_make_init_function" |), + M.get_name (| globals, locals_stack, "_make_init_function" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__init__" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__init__" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "cls" |), "__setattr__" |), - M.get_name (| globals, "_setattr_function" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__setattr__" |), + M.get_name (| globals, locals_stack, "_setattr_function" |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "cls" |), "__delattr__" |), - M.get_name (| globals, "_delattr_function" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__delattr__" |), + M.get_name (| globals, locals_stack, "_delattr_function" |) |) in let _ := M.return_ (| M.call (| M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__name__" |); - M.get_field (| M.get_name (| globals, "cls" |), "__bases__" |); + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__name__" |); + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__bases__" |); M.call (| - M.get_name (| globals, "dict" |), + M.get_name (| globals, locals_stack, "dict" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__dict__" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__dict__" |) ], make_dict [] |) @@ -4346,7 +4426,7 @@ Definition slotted_freezable : Value.t -> Value.t -> M := Definition S : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "S" ], @@ -4355,8 +4435,9 @@ Definition S : Value.t := M.run ltac:(M.monadic ( )). Definition modify : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `obj` (which must be [`@slotted_freezable`]), and modify it by applying `f`. The returned copy will be frozen. @@ -4364,42 +4445,42 @@ Definition modify : Value.t -> Value.t -> M := [`@slotted_freezable`]: ref:ethereum.base_types.slotted_freezable " in let _ := M.assert (| M.call (| - M.get_name (| globals, "is_dataclass" |), + M.get_name (| globals, locals_stack, "is_dataclass" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "obj" |); - M.get_name (| globals, "SlottedFreezable" |) + M.get_name (| globals, locals_stack, "obj" |); + M.get_name (| globals, locals_stack, "SlottedFreezable" |) ], make_dict [] |) |) in let _ := M.assign_local (| "new_obj" , M.call (| - M.get_name (| globals, "replace" |), + M.get_name (| globals, locals_stack, "replace" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ - M.get_name (| globals, "new_obj" |) + M.get_name (| globals, locals_stack, "new_obj" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "new_obj" |), "_frozen" |), + M.get_field (| M.get_name (| globals, locals_stack, "new_obj" |), "_frozen" |), Constant.bool true |) in let _ := M.return_ (| - M.get_name (| globals, "new_obj" |) + M.get_name (| globals, locals_stack, "new_obj" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/__init__.v b/CoqOfPython/ethereum/berlin/__init__.v index 9616412..81fb7fc 100644 --- a/CoqOfPython/ethereum/berlin/__init__.v +++ b/CoqOfPython/ethereum/berlin/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.__init__". +Definition globals : Globals.t := "ethereum.berlin.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -14,7 +16,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 12244000 ], diff --git a/CoqOfPython/ethereum/berlin/blocks.v b/CoqOfPython/ethereum/berlin/blocks.v index 8ab9689..092d01e 100644 --- a/CoqOfPython/ethereum/berlin/blocks.v +++ b/CoqOfPython/ethereum/berlin/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.blocks". +Definition globals : Globals.t := "ethereum.berlin.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/berlin/bloom.v b/CoqOfPython/ethereum/berlin/bloom.v index a94f117..b2b59a3 100644 --- a/CoqOfPython/ethereum/berlin/bloom.v +++ b/CoqOfPython/ethereum/berlin/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.bloom". +Definition globals : Globals.t := "ethereum.berlin.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_berlin_fork_types_imports_Bloom : IsImported globals "ethereum.berlin.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/fork.v b/CoqOfPython/ethereum/berlin/fork.v index 3a85cfb..fc29b97 100644 --- a/CoqOfPython/ethereum/berlin/fork.v +++ b/CoqOfPython/ethereum/berlin/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.fork". +Definition globals : Globals.t := "ethereum.berlin.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -148,7 +150,7 @@ Axiom ethereum_berlin_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -172,7 +174,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -190,10 +192,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -215,8 +217,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -236,13 +239,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -265,7 +269,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -276,9 +280,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -300,17 +304,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -323,13 +327,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -340,20 +344,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -378,111 +383,111 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -491,9 +496,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -502,9 +507,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -518,8 +523,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -540,101 +546,101 @@ Definition validate_header : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -643,28 +649,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -690,26 +697,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -717,8 +724,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -736,9 +744,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -746,25 +754,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -773,41 +781,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -831,35 +840,36 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -883,7 +893,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -892,10 +902,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -905,9 +915,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -917,7 +927,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -934,8 +944,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -978,22 +989,22 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1002,16 +1013,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1019,9 +1030,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1031,11 +1042,11 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -1043,18 +1054,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1062,49 +1073,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1113,56 +1124,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1173,8 +1184,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1199,27 +1211,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1228,9 +1240,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1248,46 +1260,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1298,19 +1310,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1319,23 +1331,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1343,16 +1355,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1366,13 +1378,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1387,11 +1399,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1399,88 +1411,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1493,8 +1505,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1523,44 +1536,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1572,19 +1585,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1597,8 +1610,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1626,30 +1640,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1657,91 +1671,91 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -1749,7 +1763,7 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -1758,10 +1772,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -1769,25 +1783,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -1811,14 +1825,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1826,10 +1840,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1837,20 +1851,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1859,10 +1873,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1870,41 +1884,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1912,31 +1926,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1947,20 +1961,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1973,14 +1987,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1992,27 +2006,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2028,13 +2042,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -2063,17 +2078,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -2088,8 +2103,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -2118,14 +2134,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2133,7 +2149,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2141,7 +2157,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2155,9 +2171,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2168,7 +2184,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2187,10 +2203,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2198,26 +2214,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -2233,17 +2249,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -2252,8 +2268,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2276,47 +2293,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2324,10 +2341,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2335,19 +2352,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2357,18 +2374,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2380,58 +2397,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2448,10 +2465,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2460,15 +2477,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2485,13 +2502,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2506,8 +2523,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2523,12 +2541,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2539,8 +2557,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2558,19 +2577,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2586,8 +2605,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -2603,14 +2623,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2622,8 +2642,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2657,12 +2678,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2673,8 +2694,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2705,18 +2727,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2733,10 +2755,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2753,8 +2775,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2772,8 +2794,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2817,21 +2840,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -2841,11 +2864,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2863,13 +2886,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2878,13 +2901,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -2895,7 +2918,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2905,7 +2928,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2915,13 +2938,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/fork_types.v b/CoqOfPython/ethereum/berlin/fork_types.v index 3502e2f..d33ec17 100644 --- a/CoqOfPython/ethereum/berlin/fork_types.v +++ b/CoqOfPython/ethereum/berlin/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.fork_types". +Definition globals : Globals.t := "ethereum.berlin.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/berlin/state.v b/CoqOfPython/ethereum/berlin/state.v index 58d88b0..f9ee9d5 100644 --- a/CoqOfPython/ethereum/berlin/state.v +++ b/CoqOfPython/ethereum/berlin/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.state". +Definition globals : Globals.t := "ethereum.berlin.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1163,19 +1191,20 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1194,14 +1223,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,18 +1243,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1234,7 +1263,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1242,7 +1271,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1255,10 +1284,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1266,14 +1295,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/transactions.v b/CoqOfPython/ethereum/berlin/transactions.v index bafffab..8651cfc 100644 --- a/CoqOfPython/ethereum/berlin/transactions.v +++ b/CoqOfPython/ethereum/berlin/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.transactions". +Definition globals : Globals.t := "ethereum.berlin.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -90,14 +92,15 @@ Definition AccessListTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -105,17 +108,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -124,10 +127,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -137,9 +140,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -149,7 +152,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -162,8 +165,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -171,36 +175,36 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -213,7 +217,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/berlin/trie.v b/CoqOfPython/ethereum/berlin/trie.v index 9dbed51..3390556 100644 --- a/CoqOfPython/ethereum/berlin/trie.v +++ b/CoqOfPython/ethereum/berlin/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.trie". +Definition globals : Globals.t := "ethereum.berlin.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_berlin_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,34 +124,34 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -187,14 +189,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -218,7 +221,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -234,10 +237,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -246,13 +249,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -261,10 +264,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -273,13 +276,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -288,10 +291,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -300,9 +303,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -310,7 +313,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -327,9 +330,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -339,9 +342,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -350,16 +353,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -369,8 +372,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -380,25 +384,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -410,10 +414,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -421,13 +425,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -442,27 +446,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -486,8 +490,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -504,14 +509,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -522,8 +527,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -543,8 +549,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -552,14 +558,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -571,18 +577,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -602,10 +609,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -613,21 +620,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -640,11 +648,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -652,12 +660,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -665,7 +673,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -680,9 +688,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -690,8 +698,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -728,7 +737,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -739,9 +748,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -752,13 +761,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -766,15 +775,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -784,20 +793,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -815,7 +824,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -823,13 +832,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -838,15 +847,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -856,20 +865,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -887,9 +896,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -897,8 +906,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -915,14 +925,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -933,26 +943,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -960,17 +970,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -982,9 +992,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -992,8 +1002,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1014,9 +1025,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1025,25 +1036,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1051,13 +1062,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1071,9 +1082,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1081,13 +1092,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1095,15 +1106,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1113,22 +1124,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1137,13 +1148,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1164,10 +1176,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1175,14 +1187,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1200,12 +1212,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1218,12 +1230,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1235,18 +1247,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1256,8 +1268,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1281,9 +1294,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1302,12 +1315,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1320,9 +1333,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1333,24 +1346,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1360,8 +1373,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1369,31 +1382,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1408,7 +1421,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1429,7 +1442,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1437,30 +1450,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1480,9 +1493,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1490,7 +1503,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1508,21 +1521,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1530,19 +1543,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1551,8 +1564,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1561,17 +1574,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1584,10 +1597,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/utils/__init__.v b/CoqOfPython/ethereum/berlin/utils/__init__.v index 0c0263a..f50a7d9 100644 --- a/CoqOfPython/ethereum/berlin/utils/__init__.v +++ b/CoqOfPython/ethereum/berlin/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.utils.__init__". +Definition globals : Globals.t := "ethereum.berlin.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/berlin/utils/address.v b/CoqOfPython/ethereum/berlin/utils/address.v index dd8319d..be75ce6 100644 --- a/CoqOfPython/ethereum/berlin/utils/address.v +++ b/CoqOfPython/ethereum/berlin/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.utils.address". +Definition globals : Globals.t := "ethereum.berlin.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_berlin_fork_types_imports_Address : IsImported globals "ethereum.berlin.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/utils/hexadecimal.v b/CoqOfPython/ethereum/berlin/utils/hexadecimal.v index 4b247b7..11e9b6e 100644 --- a/CoqOfPython/ethereum/berlin/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/berlin/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.berlin.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_berlin_fork_types_imports_Root : IsImported globals "ethereum.berlin.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/berlin/utils/message.v b/CoqOfPython/ethereum/berlin/utils/message.v index 6ce9be0..1b6ccca 100644 --- a/CoqOfPython/ethereum/berlin/utils/message.v +++ b/CoqOfPython/ethereum/berlin/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.utils.message". +Definition globals : Globals.t := "ethereum.berlin.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_berlin_utils_address_imports_compute_contract_address : IsImported globals "ethereum.berlin.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/vm/__init__.v b/CoqOfPython/ethereum/berlin/vm/__init__.v index fcd61d5..eb756e2 100644 --- a/CoqOfPython/ethereum/berlin/vm/__init__.v +++ b/CoqOfPython/ethereum/berlin/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.__init__". +Definition globals : Globals.t := "ethereum.berlin.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,8 +99,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -111,30 +114,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -142,19 +145,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,24 +167,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -196,15 +200,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -217,8 +221,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -226,19 +230,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -254,7 +258,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/exceptions.v b/CoqOfPython/ethereum/berlin/vm/exceptions.v index 20acb2f..55de82f 100644 --- a/CoqOfPython/ethereum/berlin/vm/exceptions.v +++ b/CoqOfPython/ethereum/berlin/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.exceptions". +Definition globals : Globals.t := "ethereum.berlin.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/berlin/vm/gas.v b/CoqOfPython/ethereum/berlin/vm/gas.v index febe9f3..9a59f10 100644 --- a/CoqOfPython/ethereum/berlin/vm/gas.v +++ b/CoqOfPython/ethereum/berlin/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.gas". +Definition globals : Globals.t := "ethereum.berlin.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_berlin_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -86,7 +88,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -116,7 +118,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -126,7 +128,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -136,7 +138,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -166,7 +168,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -176,7 +178,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -196,7 +198,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -206,7 +208,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -216,7 +218,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -226,7 +228,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -236,7 +238,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -246,7 +248,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -256,7 +258,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -266,7 +268,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -276,7 +278,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -286,7 +288,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -296,7 +298,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -306,7 +308,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -326,7 +328,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -336,7 +338,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -346,7 +348,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -356,7 +358,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -366,7 +368,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -376,7 +378,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -386,7 +388,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -396,7 +398,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -406,7 +408,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -416,7 +418,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -426,7 +428,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -436,7 +438,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -446,7 +448,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -475,8 +477,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -489,13 +492,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -506,22 +509,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -531,8 +534,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -552,9 +556,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -564,15 +568,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -581,16 +585,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,7 +624,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -629,12 +634,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -644,14 +649,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -665,9 +670,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -675,20 +680,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -701,8 +706,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -716,16 +721,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -733,9 +738,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -744,13 +749,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -760,10 +765,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -771,8 +776,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -803,13 +809,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -817,32 +823,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -856,18 +862,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -878,15 +884,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -895,8 +901,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -912,9 +919,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/__init__.v b/CoqOfPython/ethereum/berlin/vm/instructions/__init__.v index 0eae3b0..4ab52a9 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/berlin/vm/instructions/arithmetic.v index ea8f027..44f4156 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/bitwise.v b/CoqOfPython/ethereum/berlin/vm/instructions/bitwise.v index f18e7c2..7ca6973 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/block.v b/CoqOfPython/ethereum/berlin/vm/instructions/block.v index 055cd5d..52e5f80 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/block.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.block". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,14 +350,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -361,21 +370,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -384,7 +393,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/comparison.v b/CoqOfPython/ethereum/berlin/vm/instructions/comparison.v index 6815b65..3d23118 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/control_flow.v b/CoqOfPython/ethereum/berlin/vm/instructions/control_flow.v index d084bbb..2a53276 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/environment.v b/CoqOfPython/ethereum/berlin/vm/instructions/environment.v index 973b275..83b757d 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -149,16 +153,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -166,17 +170,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -185,32 +189,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -223,21 +228,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -246,14 +251,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -265,21 +271,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -288,14 +294,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -307,31 +314,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -345,30 +353,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -379,13 +387,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -394,14 +402,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -413,24 +422,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -442,14 +451,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -465,9 +475,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -475,9 +485,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -485,9 +495,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -496,12 +506,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -514,76 +524,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -595,24 +606,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -624,14 +635,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -647,9 +659,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -657,9 +669,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -667,9 +679,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,12 +690,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -696,76 +708,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -777,21 +790,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -800,14 +813,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -820,12 +834,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -837,16 +851,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -854,17 +868,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -873,16 +887,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -894,23 +908,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -923,12 +938,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -939,9 +954,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -949,9 +964,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -959,9 +974,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -970,12 +985,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -988,18 +1003,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1009,21 +1024,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1032,22 +1047,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1056,19 +1071,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1076,34 +1091,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1114,24 +1130,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1143,14 +1159,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1162,9 +1179,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1172,9 +1189,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1182,9 +1199,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1193,12 +1210,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1211,108 +1228,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1323,12 +1341,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1340,16 +1358,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1357,17 +1375,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1376,10 +1394,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1388,15 +1406,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1409,12 +1427,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1425,23 +1443,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1453,35 +1472,35 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/keccak.v b/CoqOfPython/ethereum/berlin/vm/instructions/keccak.v index 3adfdb0..8f94775 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/log.v b/CoqOfPython/ethereum/berlin/vm/instructions/log.v index 3add2f4..9b206aa 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/log.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.log". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_berlin_vm_stack_imports_pop : IsImported globals "ethereum.berlin.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/memory.v b/CoqOfPython/ethereum/berlin/vm/instructions/memory.v index c93d543..b0b7a2b 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/stack.v b/CoqOfPython/ethereum/berlin/vm/instructions/stack.v index 77860ad..5016b0e 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_berlin_vm_memory_imports_buffer_read : IsImported globals "ethereum.berlin.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/storage.v b/CoqOfPython/ethereum/berlin/vm/instructions/storage.v index 8bf28fd..85002dc 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -59,8 +61,9 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -75,9 +78,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -89,16 +92,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -106,17 +109,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -125,33 +128,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -165,9 +169,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -178,32 +182,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -211,11 +215,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -223,7 +227,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -234,22 +238,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -261,13 +265,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -277,7 +281,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -285,7 +289,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -294,8 +298,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -306,7 +310,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -314,8 +318,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -324,18 +328,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -346,11 +350,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -365,12 +369,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -379,11 +383,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -397,8 +401,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -406,20 +410,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -430,16 +434,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -458,34 +462,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/instructions/system.v b/CoqOfPython/ethereum/berlin/vm/instructions/system.v index 313e0af..f1bc612 100644 --- a/CoqOfPython/ethereum/berlin/vm/instructions/system.v +++ b/CoqOfPython/ethereum/berlin/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.instructions.system". +Definition globals : Globals.t := "ethereum.berlin.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -107,28 +109,29 @@ Axiom ethereum_berlin_vm_stack_imports_push : IsImported globals "ethereum.berlin.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -138,32 +141,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -173,15 +176,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -197,10 +200,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -210,15 +213,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -239,29 +242,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -281,27 +284,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -309,10 +312,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -320,27 +323,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -353,25 +356,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -383,8 +386,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -396,9 +400,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -406,9 +410,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -416,9 +420,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -426,46 +430,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -474,26 +478,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -508,9 +513,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -518,9 +523,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -528,9 +533,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -539,9 +544,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -552,11 +557,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -566,12 +571,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -582,43 +587,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -627,26 +632,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -658,9 +664,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,63 +684,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -742,24 +749,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -779,11 +786,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -791,10 +798,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -802,7 +809,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -810,10 +817,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -821,27 +828,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -854,23 +861,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -884,16 +891,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -905,14 +912,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -921,8 +928,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -934,12 +942,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -950,12 +958,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -966,9 +974,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -976,9 +984,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -986,9 +994,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -996,9 +1004,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1006,9 +1014,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1016,12 +1024,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1031,28 +1039,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1062,16 +1070,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1079,7 +1087,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1087,7 +1095,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1095,13 +1103,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1109,56 +1117,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1167,25 +1175,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1194,17 +1202,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,32 +1222,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1247,14 +1255,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1266,12 +1275,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1282,12 +1291,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1298,9 +1307,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1308,9 +1317,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1318,9 +1327,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1328,9 +1337,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1338,26 +1347,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1367,28 +1376,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1397,13 +1406,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1411,58 +1420,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1471,17 +1480,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1491,32 +1500,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1524,14 +1533,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1543,12 +1553,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1558,28 +1568,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1591,20 +1601,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1617,7 +1627,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1626,33 +1636,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1664,15 +1674,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1680,28 +1690,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1709,33 +1719,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1745,9 +1755,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1755,19 +1765,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1777,15 +1787,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1797,12 +1808,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1813,12 +1824,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1829,9 +1840,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1839,9 +1850,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1849,9 +1860,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1859,9 +1870,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1869,12 +1880,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1884,104 +1895,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1993,12 +2005,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2009,12 +2021,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2025,9 +2037,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2035,9 +2047,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2045,9 +2057,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2055,9 +2067,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2065,12 +2077,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2080,110 +2092,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2195,9 +2208,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2205,9 +2218,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2215,54 +2228,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/interpreter.v b/CoqOfPython/ethereum/berlin/vm/interpreter.v index c0c52ad..50d490b 100644 --- a/CoqOfPython/ethereum/berlin/vm/interpreter.v +++ b/CoqOfPython/ethereum/berlin/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.interpreter". +Definition globals : Globals.t := "ethereum.berlin.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -124,7 +126,7 @@ Axiom ethereum_berlin_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -147,8 +149,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -170,9 +173,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -184,10 +187,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -195,44 +198,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -246,10 +249,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -262,10 +265,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -274,13 +277,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -290,12 +293,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -312,14 +315,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -327,7 +330,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -335,7 +338,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -347,22 +350,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -372,29 +375,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -402,8 +405,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -420,43 +424,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -464,24 +468,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -489,22 +493,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -524,13 +529,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -542,17 +547,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -560,10 +565,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -571,12 +576,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -588,10 +593,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -599,13 +604,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -613,22 +618,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -646,14 +652,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -661,13 +667,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/memory.v b/CoqOfPython/ethereum/berlin/vm/memory.v index 62e26d1..d953a23 100644 --- a/CoqOfPython/ethereum/berlin/vm/memory.v +++ b/CoqOfPython/ethereum/berlin/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.memory". +Definition globals : Globals.t := "ethereum.berlin.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/__init__.v index 311a52a..d340e5d 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/alt_bn128.v index 8bfbd17..50f80e6 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_berlin_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.berlin.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/blake2f.v index 5afc3b4..3cdd347 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_berlin_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.berlin.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ecrecover.v index 9c5863b..1769bb3 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_berlin_vm_memory_imports_buffer_read : IsImported globals "ethereum.berlin.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/identity.v index 3663ec2..86058e6 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_berlin_vm_gas_imports_charge_gas : IsImported globals "ethereum.berlin.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/mapping.v index 14f0d14..30e740d 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/modexp.v index aa24c23..70888f6 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ripemd160.v index a699925..01feab1 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_berlin_vm_gas_imports_charge_gas : IsImported globals "ethereum.berlin.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/sha256.v index b3c060c..d672ada 100644 --- a/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/berlin/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.berlin.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_berlin_vm_gas_imports_charge_gas : IsImported globals "ethereum.berlin.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/berlin/vm/runtime.v b/CoqOfPython/ethereum/berlin/vm/runtime.v index 03bc450..48203e5 100644 --- a/CoqOfPython/ethereum/berlin/vm/runtime.v +++ b/CoqOfPython/ethereum/berlin/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.runtime". +Definition globals : Globals.t := "ethereum.berlin.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_berlin_vm_instructions_imports_Ops : IsImported globals "ethereum.berlin.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/berlin/vm/stack.v b/CoqOfPython/ethereum/berlin/vm/stack.v index 812da9c..1788fe7 100644 --- a/CoqOfPython/ethereum/berlin/vm/stack.v +++ b/CoqOfPython/ethereum/berlin/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.berlin.vm.stack". +Definition globals : Globals.t := "ethereum.berlin.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_berlin_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.berlin.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/__init__.v b/CoqOfPython/ethereum/byzantium/__init__.v index 2dfebd4..326e0ea 100644 --- a/CoqOfPython/ethereum/byzantium/__init__.v +++ b/CoqOfPython/ethereum/byzantium/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.__init__". +Definition globals : Globals.t := "ethereum.byzantium.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -14,7 +16,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 4370000 ], diff --git a/CoqOfPython/ethereum/byzantium/blocks.v b/CoqOfPython/ethereum/byzantium/blocks.v index 93405c6..e211724 100644 --- a/CoqOfPython/ethereum/byzantium/blocks.v +++ b/CoqOfPython/ethereum/byzantium/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.blocks". +Definition globals : Globals.t := "ethereum.byzantium.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/byzantium/bloom.v b/CoqOfPython/ethereum/byzantium/bloom.v index 4b8bc45..b643468 100644 --- a/CoqOfPython/ethereum/byzantium/bloom.v +++ b/CoqOfPython/ethereum/byzantium/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.bloom". +Definition globals : Globals.t := "ethereum.byzantium.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_byzantium_fork_types_imports_Bloom : IsImported globals "ethereum.byzantium.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/fork.v b/CoqOfPython/ethereum/byzantium/fork.v index 87d1e53..cf7386a 100644 --- a/CoqOfPython/ethereum/byzantium/fork.v +++ b/CoqOfPython/ethereum/byzantium/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.fork". +Definition globals : Globals.t := "ethereum.byzantium.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -134,7 +136,7 @@ Axiom ethereum_byzantium_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 3, @@ -158,7 +160,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -176,10 +178,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -201,8 +203,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -222,13 +225,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -251,7 +255,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -262,9 +266,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -286,17 +290,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -309,13 +313,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -326,20 +330,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -364,111 +369,111 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -477,9 +482,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -488,9 +493,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -504,8 +509,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -526,101 +532,101 @@ Definition validate_header : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -629,28 +635,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -676,26 +683,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -703,8 +710,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -722,9 +730,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -732,25 +740,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -759,41 +767,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -817,35 +826,36 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -869,13 +879,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -890,8 +900,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -934,51 +945,51 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -986,18 +997,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1005,49 +1016,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1056,56 +1067,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1116,8 +1127,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1142,27 +1154,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1171,9 +1183,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1191,46 +1203,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1241,19 +1253,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1262,23 +1274,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1286,16 +1298,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1309,13 +1321,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1330,11 +1342,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1342,88 +1354,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1436,8 +1448,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1466,44 +1479,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1515,19 +1528,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1540,8 +1553,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1569,30 +1583,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1600,98 +1614,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1699,10 +1713,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1710,20 +1724,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1732,10 +1746,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1743,41 +1757,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1785,31 +1799,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1820,20 +1834,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1846,14 +1860,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1865,27 +1879,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1901,13 +1915,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1936,17 +1951,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1961,8 +1976,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1991,14 +2007,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2006,7 +2022,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2014,7 +2030,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2028,9 +2044,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2041,7 +2057,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2054,14 +2070,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -2070,8 +2086,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2094,47 +2111,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2143,12 +2160,12 @@ Definition recover_sender : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2158,18 +2175,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2181,58 +2198,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2244,13 +2261,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2265,8 +2282,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2282,12 +2300,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2298,8 +2316,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2317,19 +2336,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2345,8 +2364,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2380,12 +2400,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2396,8 +2416,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2428,18 +2449,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2456,10 +2477,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2476,8 +2497,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2495,8 +2516,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2540,21 +2562,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -2564,11 +2586,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2586,13 +2608,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2601,13 +2623,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -2618,7 +2640,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2628,7 +2650,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2638,13 +2660,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/fork_types.v b/CoqOfPython/ethereum/byzantium/fork_types.v index b564ee7..bf20981 100644 --- a/CoqOfPython/ethereum/byzantium/fork_types.v +++ b/CoqOfPython/ethereum/byzantium/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.fork_types". +Definition globals : Globals.t := "ethereum.byzantium.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/byzantium/state.v b/CoqOfPython/ethereum/byzantium/state.v index 525fbd8..a202e2d 100644 --- a/CoqOfPython/ethereum/byzantium/state.v +++ b/CoqOfPython/ethereum/byzantium/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.state". +Definition globals : Globals.t := "ethereum.byzantium.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,8 +710,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -714,10 +732,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -725,9 +743,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -737,12 +755,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -753,8 +771,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -775,10 +794,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -786,15 +805,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -804,12 +823,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -822,8 +841,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -842,10 +862,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -854,7 +874,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -868,9 +888,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -880,12 +900,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -898,28 +918,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -929,36 +950,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -975,19 +998,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1003,21 +1027,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1029,8 +1053,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1044,19 +1069,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1073,19 +1099,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1100,11 +1127,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/byzantium/transactions.v b/CoqOfPython/ethereum/byzantium/transactions.v index d474dfc..9fcc79a 100644 --- a/CoqOfPython/ethereum/byzantium/transactions.v +++ b/CoqOfPython/ethereum/byzantium/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.transactions". +Definition globals : Globals.t := "ethereum.byzantium.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/byzantium/trie.v b/CoqOfPython/ethereum/byzantium/trie.v index 4999d6e..8253548 100644 --- a/CoqOfPython/ethereum/byzantium/trie.v +++ b/CoqOfPython/ethereum/byzantium/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.trie". +Definition globals : Globals.t := "ethereum.byzantium.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_byzantium_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/utils/__init__.v b/CoqOfPython/ethereum/byzantium/utils/__init__.v index 418c984..8226fd5 100644 --- a/CoqOfPython/ethereum/byzantium/utils/__init__.v +++ b/CoqOfPython/ethereum/byzantium/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.utils.__init__". +Definition globals : Globals.t := "ethereum.byzantium.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/byzantium/utils/address.v b/CoqOfPython/ethereum/byzantium/utils/address.v index f8a4ecd..0ba31e5 100644 --- a/CoqOfPython/ethereum/byzantium/utils/address.v +++ b/CoqOfPython/ethereum/byzantium/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.utils.address". +Definition globals : Globals.t := "ethereum.byzantium.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_byzantium_fork_types_imports_Address : IsImported globals "ethereum.byzantium.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -56,11 +59,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -75,8 +78,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -96,14 +100,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -115,7 +119,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -124,9 +128,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -134,9 +138,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/utils/hexadecimal.v b/CoqOfPython/ethereum/byzantium/utils/hexadecimal.v index 5540c16..6424c2a 100644 --- a/CoqOfPython/ethereum/byzantium/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/byzantium/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.byzantium.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_byzantium_fork_types_imports_Root : IsImported globals "ethereum.byzantium.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/byzantium/utils/message.v b/CoqOfPython/ethereum/byzantium/utils/message.v index c60fbeb..195323c 100644 --- a/CoqOfPython/ethereum/byzantium/utils/message.v +++ b/CoqOfPython/ethereum/byzantium/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.utils.message". +Definition globals : Globals.t := "ethereum.byzantium.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_byzantium_utils_address_imports_compute_contract_address : IsImported globals "ethereum.byzantium.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -85,10 +88,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -97,20 +100,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -124,7 +127,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -133,7 +136,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -142,10 +145,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -153,19 +156,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -174,14 +177,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -192,7 +195,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -204,7 +207,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/vm/__init__.v b/CoqOfPython/ethereum/byzantium/vm/__init__.v index b02d05c..34ff2a1 100644 --- a/CoqOfPython/ethereum/byzantium/vm/__init__.v +++ b/CoqOfPython/ethereum/byzantium/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.__init__". +Definition globals : Globals.t := "ethereum.byzantium.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -93,8 +95,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -107,30 +110,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -138,19 +141,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -162,8 +165,9 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -178,15 +182,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -199,8 +203,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -208,19 +212,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -236,7 +240,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/exceptions.v b/CoqOfPython/ethereum/byzantium/vm/exceptions.v index 7375e6c..0e595d2 100644 --- a/CoqOfPython/ethereum/byzantium/vm/exceptions.v +++ b/CoqOfPython/ethereum/byzantium/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.exceptions". +Definition globals : Globals.t := "ethereum.byzantium.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/byzantium/vm/gas.v b/CoqOfPython/ethereum/byzantium/vm/gas.v index bd2fb66..bf9d020 100644 --- a/CoqOfPython/ethereum/byzantium/vm/gas.v +++ b/CoqOfPython/ethereum/byzantium/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.gas". +Definition globals : Globals.t := "ethereum.byzantium.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_byzantium_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -86,7 +88,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -116,7 +118,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -126,7 +128,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -136,7 +138,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -166,7 +168,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -176,7 +178,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -196,7 +198,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -206,7 +208,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -216,7 +218,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -226,7 +228,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 400 ], @@ -236,7 +238,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -246,7 +248,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -256,7 +258,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -266,7 +268,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -276,7 +278,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -286,7 +288,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -296,7 +298,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -306,7 +308,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -326,7 +328,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -336,7 +338,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -346,7 +348,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -356,7 +358,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -366,7 +368,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -376,7 +378,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -386,7 +388,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -396,7 +398,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -406,7 +408,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -416,7 +418,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -426,7 +428,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -436,7 +438,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -465,8 +467,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -479,13 +482,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -496,22 +499,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -521,8 +524,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -542,9 +546,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -554,15 +558,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -571,16 +575,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,12 +624,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -634,14 +639,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -655,9 +660,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -665,20 +670,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -691,8 +696,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -706,16 +711,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -723,9 +728,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -734,13 +739,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -750,10 +755,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -761,8 +766,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -793,13 +799,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -807,32 +813,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -846,18 +852,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -868,15 +874,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -885,8 +891,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -902,9 +909,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/__init__.v b/CoqOfPython/ethereum/byzantium/vm/instructions/__init__.v index f76e351..4299835 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/byzantium/vm/instructions/arithmetic.v index 554d565..3a47aa4 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/bitwise.v b/CoqOfPython/ethereum/byzantium/vm/instructions/bitwise.v index 78deb13..1ceeb8c 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,42 +62,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -108,9 +112,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,42 +122,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -167,9 +172,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -177,42 +182,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -226,39 +232,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -273,9 +280,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -283,18 +290,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -302,7 +309,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -310,7 +317,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -324,15 +331,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -340,16 +347,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -357,16 +364,16 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/block.v b/CoqOfPython/ethereum/byzantium/vm/instructions/block.v index deb5d8d..e750866 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/block.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.block". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/comparison.v b/CoqOfPython/ethereum/byzantium/vm/instructions/comparison.v index b282bad..0a28fba 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/control_flow.v b/CoqOfPython/ethereum/byzantium/vm/instructions/control_flow.v index 01a71f7..1cca22a 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/environment.v b/CoqOfPython/ethereum/byzantium/vm/instructions/environment.v index 150687d..03bc9e7 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -68,8 +70,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -81,21 +84,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -104,14 +107,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -124,12 +128,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -138,42 +142,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -186,21 +191,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -209,14 +214,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -228,21 +234,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -251,14 +257,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -270,31 +277,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -308,30 +316,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -342,13 +350,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -357,14 +365,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -376,24 +385,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -405,14 +414,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -428,9 +438,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -438,9 +448,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -448,9 +458,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -459,12 +469,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -477,76 +487,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -558,24 +569,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -587,14 +598,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -610,9 +622,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -620,9 +632,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -630,9 +642,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -641,12 +653,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -659,76 +671,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -740,21 +753,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -763,14 +776,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -783,12 +797,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -797,26 +811,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -828,23 +842,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -857,12 +872,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,9 +888,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -883,9 +898,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -893,9 +908,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -904,12 +919,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -922,52 +937,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -975,34 +990,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1013,24 +1029,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1042,14 +1058,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1061,9 +1078,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,9 +1088,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1081,9 +1098,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1092,12 +1109,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1110,101 +1127,101 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/keccak.v b/CoqOfPython/ethereum/byzantium/vm/instructions/keccak.v index c54b6cc..c95d552 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/log.v b/CoqOfPython/ethereum/byzantium/vm/instructions/log.v index 4f0424b..31233e1 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/log.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.log". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_byzantium_vm_stack_imports_pop : IsImported globals "ethereum.byzantium.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/memory.v b/CoqOfPython/ethereum/byzantium/vm/instructions/memory.v index ff2aeb3..92f11c5 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/stack.v b/CoqOfPython/ethereum/byzantium/vm/instructions/stack.v index 2b2ad26..9d68ac8 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_byzantium_vm_memory_imports_buffer_read : IsImported globals "ethereum.byzantium.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/storage.v b/CoqOfPython/ethereum/byzantium/vm/instructions/storage.v index 64a99f4..a14dbd9 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -48,8 +50,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -64,9 +67,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -75,43 +78,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -125,9 +129,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -138,9 +142,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -148,11 +152,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -162,12 +166,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -176,14 +180,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -192,12 +196,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -206,8 +210,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -215,34 +219,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/instructions/system.v b/CoqOfPython/ethereum/byzantium/vm/instructions/system.v index e75fc6e..4cbca10 100644 --- a/CoqOfPython/ethereum/byzantium/vm/instructions/system.v +++ b/CoqOfPython/ethereum/byzantium/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.instructions.system". +Definition globals : Globals.t := "ethereum.byzantium.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -98,8 +100,9 @@ Axiom ethereum_byzantium_vm_stack_imports_push : IsImported globals "ethereum.byzantium.vm.stack" "push". Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -112,9 +115,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -122,9 +125,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -132,9 +135,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,23 +145,23 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -166,12 +169,12 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -181,40 +184,40 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -222,14 +225,14 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -242,15 +245,15 @@ Definition create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -266,10 +269,10 @@ Definition create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -278,11 +281,11 @@ Definition create : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -293,8 +296,8 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in M.pure Constant.None_ (* else *) @@ -303,29 +306,29 @@ Definition create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -340,27 +343,27 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -368,10 +371,10 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -379,27 +382,27 @@ Definition create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -412,25 +415,25 @@ Definition create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -445,14 +448,15 @@ Definition create : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -464,9 +468,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -474,9 +478,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -484,63 +488,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -548,24 +553,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -585,11 +590,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -597,10 +602,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -608,7 +613,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -616,10 +621,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -627,27 +632,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -660,23 +665,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -690,16 +695,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -711,14 +716,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -727,8 +732,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -740,12 +746,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -756,12 +762,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -772,9 +778,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -782,9 +788,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -792,9 +798,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -802,9 +808,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -812,9 +818,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -822,12 +828,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -839,15 +845,15 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), ltac:(M.monadic ( M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) @@ -856,7 +862,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -864,7 +870,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -872,13 +878,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -886,56 +892,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -944,25 +950,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -971,17 +977,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -991,32 +997,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1024,14 +1030,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1043,12 +1050,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1059,12 +1066,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1075,9 +1082,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1085,9 +1092,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1095,9 +1102,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1105,9 +1112,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1115,26 +1122,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1145,13 +1152,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1159,58 +1166,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1219,17 +1226,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1239,32 +1246,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1272,14 +1279,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1291,12 +1299,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,27 +1314,27 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1339,7 +1347,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1348,33 +1356,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1386,15 +1394,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1402,28 +1410,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1431,33 +1439,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1467,9 +1475,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1477,19 +1485,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1499,15 +1507,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1519,12 +1528,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1535,12 +1544,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1551,9 +1560,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1561,9 +1570,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1571,9 +1580,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1581,9 +1590,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1591,12 +1600,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1605,76 +1614,77 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1686,12 +1696,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1702,12 +1712,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1718,9 +1728,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1728,9 +1738,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1738,9 +1748,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1748,9 +1758,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1758,12 +1768,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1772,82 +1782,83 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -1859,9 +1870,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1869,9 +1880,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1879,54 +1890,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/interpreter.v b/CoqOfPython/ethereum/byzantium/vm/interpreter.v index 53559db..1c71f79 100644 --- a/CoqOfPython/ethereum/byzantium/vm/interpreter.v +++ b/CoqOfPython/ethereum/byzantium/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.interpreter". +Definition globals : Globals.t := "ethereum.byzantium.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -122,7 +124,7 @@ Axiom ethereum_byzantium_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -145,8 +147,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -168,9 +171,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -182,10 +185,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -193,44 +196,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -244,10 +247,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -260,10 +263,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -272,13 +275,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -288,12 +291,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -310,14 +313,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -325,7 +328,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -333,7 +336,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -345,48 +348,48 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -394,8 +397,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -412,35 +416,35 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -448,24 +452,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -473,22 +477,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -508,13 +513,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -526,17 +531,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -544,10 +549,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -555,12 +560,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -572,10 +577,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -583,13 +588,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -597,22 +602,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -630,14 +636,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -645,13 +651,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/memory.v b/CoqOfPython/ethereum/byzantium/vm/memory.v index 148e6c5..20c1f88 100644 --- a/CoqOfPython/ethereum/byzantium/vm/memory.v +++ b/CoqOfPython/ethereum/byzantium/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.memory". +Definition globals : Globals.t := "ethereum.byzantium.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/__init__.v index d82e958..7aff869 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/alt_bn128.v index 01b9f2c..f90e2a8 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_byzantium_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.byzantium.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 500 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 40000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 80000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ecrecover.v index 6daeeb3..1da26e6 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_byzantium_vm_memory_imports_buffer_read : IsImported globals "ethereum.byzantium.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/identity.v index 7f914dd..be43993 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_byzantium_vm_gas_imports_charge_gas : IsImported globals "ethereum.byzantium.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/mapping.v index 7088817..a9bc261 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/modexp.v index d8d7f8d..aa931ce 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,7 +37,7 @@ Axiom ethereum_byzantium_vm_memory_imports_buffer_read : Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -44,34 +46,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -87,21 +90,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -117,21 +120,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -148,36 +151,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -192,7 +195,7 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "exp_length" |), + M.get_name (| globals, locals_stack, "exp_length" |), Constant.int 32 |), (* then *) @@ -200,15 +203,15 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -227,16 +230,16 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |), @@ -244,12 +247,12 @@ Definition modexp : Value.t -> Value.t -> M := |) |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -266,22 +269,22 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.floor_div (| BinOp.mult (| M.call (| - M.get_name (| globals, "get_mult_complexity" |), + M.get_name (| globals, locals_stack, "get_mult_complexity" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -292,11 +295,11 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "adjusted_exp_length" |); + M.get_name (| globals, locals_stack, "adjusted_exp_length" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -306,7 +309,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |) |), - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) ], make_dict [] @@ -316,12 +319,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -329,9 +332,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -347,20 +350,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -371,14 +374,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -389,21 +392,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -415,39 +418,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -455,7 +458,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -466,8 +469,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_mult_complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing Karatsuba multiplication. " in @@ -475,14 +479,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 64 |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |) |) in @@ -493,7 +497,7 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 1024 |), (* then *) @@ -503,14 +507,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 4 |), BinOp.mult (| Constant.int 96, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 3072 @@ -524,14 +528,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 16 |), BinOp.mult (| Constant.int 480, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 199680 diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ripemd160.v index dcf5699..d405920 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_byzantium_vm_gas_imports_charge_gas : IsImported globals "ethereum.byzantium.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/sha256.v index 3059153..7669a50 100644 --- a/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/byzantium/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.byzantium.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_byzantium_vm_gas_imports_charge_gas : IsImported globals "ethereum.byzantium.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/byzantium/vm/runtime.v b/CoqOfPython/ethereum/byzantium/vm/runtime.v index 0417135..e5b4870 100644 --- a/CoqOfPython/ethereum/byzantium/vm/runtime.v +++ b/CoqOfPython/ethereum/byzantium/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.runtime". +Definition globals : Globals.t := "ethereum.byzantium.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_byzantium_vm_instructions_imports_Ops : IsImported globals "ethereum.byzantium.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/byzantium/vm/stack.v b/CoqOfPython/ethereum/byzantium/vm/stack.v index e9c738b..b368020 100644 --- a/CoqOfPython/ethereum/byzantium/vm/stack.v +++ b/CoqOfPython/ethereum/byzantium/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.byzantium.vm.stack". +Definition globals : Globals.t := "ethereum.byzantium.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_byzantium_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.byzantium.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/__init__.v b/CoqOfPython/ethereum/cancun/__init__.v index 2ad1a6a..c87f204 100644 --- a/CoqOfPython/ethereum/cancun/__init__.v +++ b/CoqOfPython/ethereum/cancun/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.__init__". +Definition globals : Globals.t := "ethereum.cancun.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -15,7 +17,7 @@ Axiom ethereum_fork_criteria_imports_ByTimestamp : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByTimestamp" |), + M.get_name (| globals, locals_stack, "ByTimestamp" |), make_list [ Constant.int 1710338135 ], diff --git a/CoqOfPython/ethereum/cancun/blocks.v b/CoqOfPython/ethereum/cancun/blocks.v index 540810b..6d98eb6 100644 --- a/CoqOfPython/ethereum/cancun/blocks.v +++ b/CoqOfPython/ethereum/cancun/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.blocks". +Definition globals : Globals.t := "ethereum.cancun.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/cancun/bloom.v b/CoqOfPython/ethereum/cancun/bloom.v index 8795d1e..0836db3 100644 --- a/CoqOfPython/ethereum/cancun/bloom.v +++ b/CoqOfPython/ethereum/cancun/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.bloom". +Definition globals : Globals.t := "ethereum.cancun.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_cancun_fork_types_imports_Bloom : IsImported globals "ethereum.cancun.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/fork.v b/CoqOfPython/ethereum/cancun/fork.v index 678991e..be9035f 100644 --- a/CoqOfPython/ethereum/cancun/fork.v +++ b/CoqOfPython/ethereum/cancun/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.fork". +Definition globals : Globals.t := "ethereum.cancun.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -186,10 +188,10 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -202,7 +204,7 @@ Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( Definition SYSTEM_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0xfffffffffffffffffffffffffffffffffffffffe" ], @@ -212,7 +214,7 @@ Definition SYSTEM_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BEACON_ROOTS_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02" ], @@ -222,7 +224,7 @@ Definition BEACON_ROOTS_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SYSTEM_TRANSACTION_GAS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30000000 ], @@ -249,8 +251,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -270,13 +273,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -299,7 +303,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -310,9 +314,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -334,17 +338,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -357,13 +361,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -374,20 +378,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -412,159 +417,159 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.assign_local (| "excess_blob_gas" , M.call (| - M.get_name (| globals, "calculate_excess_blob_gas" |), + M.get_name (| globals, locals_stack, "calculate_excess_blob_gas" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "excess_blob_gas" |), - M.get_name (| globals, "excess_blob_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "excess_blob_gas" |), + M.get_name (| globals, locals_stack, "excess_blob_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "block" |), "ommers" |), + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |), make_tuple [ ] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "base_fee_per_gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "prev_randao" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |); - M.get_field (| M.get_name (| globals, "block" |), "withdrawals" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_beacon_block_root" |); - M.get_name (| globals, "excess_blob_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "base_fee_per_gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "prev_randao" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "withdrawals" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_beacon_block_root" |); + M.get_name (| globals, locals_stack, "excess_blob_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "withdrawals_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "withdrawals_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "withdrawals_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "withdrawals_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "blob_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "blob_gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "blob_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "blob_gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -573,9 +578,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -584,9 +589,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -600,8 +605,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the base fee per gas for the block. @@ -624,22 +630,22 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_gas_target" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "ELASTICITY_MULTIPLIER" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "ELASTICITY_MULTIPLIER" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_name (| globals, "block_gas_limit" |); - M.get_name (| globals, "parent_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |); + M.get_name (| globals, locals_stack, "parent_gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -647,14 +653,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "expected_base_fee_per_gas" , - M.get_name (| globals, "parent_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |) |) in M.pure Constant.None_ (* else *) @@ -663,40 +669,40 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |); Constant.int 1 ], @@ -706,8 +712,8 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.add (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -716,36 +722,36 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_target" |), - M.get_name (| globals, "parent_gas_used" |) + M.get_name (| globals, locals_stack, "parent_gas_target" |), + M.get_name (| globals, locals_stack, "parent_gas_used" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.sub (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -754,9 +760,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "expected_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |) ], make_dict [] |) @@ -764,8 +770,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -784,124 +791,124 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |), - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , M.call (| - M.get_name (| globals, "calculate_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "calculate_base_fee_per_gas" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "base_fee_per_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "expected_base_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), Constant.int 0 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |), Constant.bytes "0000000000000000" |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -910,21 +917,22 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "tx"; "gas_available"; "chain_id"; "base_fee_per_gas"; "excess_blob_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "tx"; "gas_available"; "chain_id"; "base_fee_per_gas"; "excess_blob_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -962,17 +970,17 @@ Definition check_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -982,7 +990,7 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -993,7 +1001,7 @@ Definition check_transaction : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1004,9 +1012,9 @@ Definition check_transaction : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -1016,22 +1024,22 @@ Definition check_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ], make_dict [] |), BinOp.mult (| Constant.int 2, - M.get_name (| globals, "MAX_CODE_SIZE" |) + M.get_name (| globals, locals_stack, "MAX_CODE_SIZE" |) |) |) )) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1041,12 +1049,12 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1055,10 +1063,10 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1066,10 +1074,10 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1078,10 +1086,10 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "FeeMarketTransaction" |); M.get_name (| globals, "BlobTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.get_name (| globals, locals_stack, "BlobTransaction" |) ] ], make_dict [] |), @@ -1091,12 +1099,12 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1106,12 +1114,12 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1120,12 +1128,12 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "priority_fee_per_gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) ], make_dict [] @@ -1134,15 +1142,15 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_price" , BinOp.add (| - M.get_name (| globals, "priority_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |) |) |) in M.pure Constant.None_ @@ -1152,12 +1160,12 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1165,13 +1173,13 @@ Definition check_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "effective_gas_price" , - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) in let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in M.pure Constant.None_ @@ -1180,10 +1188,10 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "BlobTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |) ], make_dict [] |), @@ -1193,16 +1201,16 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_name (| globals, "Address" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1213,9 +1221,9 @@ Definition check_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "blob_versioned_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "blob_versioned_hashes" |) ], make_dict [] |), @@ -1223,7 +1231,7 @@ Definition check_transaction : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1231,24 +1239,24 @@ Definition check_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "blob_versioned_hash" |), - M.get_field (| M.get_name (| globals, "tx" |), "blob_versioned_hashes" |), + M.get_name (| globals, locals_stack, "blob_versioned_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "blob_versioned_hashes" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.not_eq (| M.slice (| - M.get_name (| globals, "blob_versioned_hash" |), + M.get_name (| globals, locals_stack, "blob_versioned_hash" |), Constant.int 0, Constant.int 1, Constant.None_ |), - M.get_name (| globals, "VERSIONED_HASH_VERSION_KZG" |) + M.get_name (| globals, locals_stack, "VERSIONED_HASH_VERSION_KZG" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1264,18 +1272,18 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_blob_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_blob_gas" |), M.call (| - M.get_name (| globals, "calculate_blob_gas_price" |), + M.get_name (| globals, locals_stack, "calculate_blob_gas_price" |), make_list [ - M.get_name (| globals, "excess_blob_gas" |) + M.get_name (| globals, locals_stack, "excess_blob_gas" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1286,18 +1294,18 @@ Definition check_transaction : Value.t -> Value.t -> M := "max_gas_fee", BinOp.mult (| M.call (| - M.get_name (| globals, "calculate_total_blob_gas" |), + M.get_name (| globals, locals_stack, "calculate_total_blob_gas" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_blob_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_blob_gas" |) |) |) in let _ := M.assign_local (| "blob_versioned_hashes" , - M.get_field (| M.get_name (| globals, "tx" |), "blob_versioned_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "blob_versioned_hashes" |) |) in M.pure Constant.None_ (* else *) @@ -1309,53 +1317,54 @@ Definition check_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "max_gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "max_gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "sender" |); M.get_name (| globals, "effective_gas_price" |); M.get_name (| globals, "blob_versioned_hashes" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "sender" |); M.get_name (| globals, locals_stack, "effective_gas_price" |); M.get_name (| globals, locals_stack, "blob_versioned_hashes" |) ] |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -1379,7 +1388,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -1388,10 +1397,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -1401,9 +1410,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1416,10 +1425,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1429,9 +1438,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1444,10 +1453,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "BlobTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |) ], make_dict [] |), @@ -1457,9 +1466,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "03", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1469,7 +1478,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -1490,8 +1499,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "prev_randao"; "transactions"; "chain_id"; "withdrawals"; "parent_beacon_block_root"; "excess_blob_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "prev_randao"; "transactions"; "chain_id"; "withdrawals"; "parent_beacon_block_root"; "excess_blob_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -1543,7 +1553,7 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "blob_gas_used" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1552,7 +1562,7 @@ Definition apply_body : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) @@ -1561,10 +1571,10 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "beacon_block_roots_contract_code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "BEACON_ROOTS_ADDRESS" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "BEACON_ROOTS_ADDRESS" |) ], make_dict [] |), "code" |) @@ -1572,7 +1582,7 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "system_tx_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -1580,7 +1590,7 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "system_tx_env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) @@ -1588,33 +1598,33 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "system_tx_output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "system_tx_message" |); - M.get_name (| globals, "system_tx_env" |) + M.get_name (| globals, locals_stack, "system_tx_message" |); + M.get_name (| globals, locals_stack, "system_tx_env" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "destroy_touched_empty_accounts" |), + M.get_name (| globals, locals_stack, "destroy_touched_empty_accounts" |), make_list [ - M.get_field (| M.get_name (| globals, "system_tx_env" |), "state" |); - M.get_field (| M.get_name (| globals, "system_tx_output" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "system_tx_env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "system_tx_output" |), "touched_accounts" |) ], make_dict [] |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1623,16 +1633,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1640,9 +1650,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1650,16 +1660,16 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |); M.get_name (| globals, "blob_versioned_hashes" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |); M.get_name (| globals, locals_stack, "blob_versioned_hashes" |) ], M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "base_fee_per_gas" |); - M.get_name (| globals, "excess_blob_gas" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "excess_blob_gas" |) ], make_dict [] |) @@ -1667,18 +1677,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1686,57 +1696,57 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in let _ := M.assign_op_local (| BinOp.add, "blob_gas_used", M.call (| - M.get_name (| globals, "calculate_total_blob_gas" |), + M.get_name (| globals, locals_stack, "calculate_total_blob_gas" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1748,55 +1758,55 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_name (| globals, "blob_gas_used" |), - M.get_name (| globals, "MAX_BLOB_GAS_PER_BLOCK" |) + M.get_name (| globals, locals_stack, "blob_gas_used" |), + M.get_name (| globals, locals_stack, "MAX_BLOB_GAS_PER_BLOCK" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "wd" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "wd" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "withdrawals" |) + M.get_name (| globals, locals_stack, "withdrawals" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "withdrawals_trie" |); + M.get_name (| globals, locals_stack, "withdrawals_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1804,9 +1814,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "wd" |) + M.get_name (| globals, locals_stack, "wd" |) ], make_dict [] |) @@ -1814,10 +1824,10 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "process_withdrawal" |), + M.get_name (| globals, locals_stack, "process_withdrawal" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "wd" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "wd" |) ], make_dict [] |) in @@ -1825,20 +1835,20 @@ Definition apply_body : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "wd" |), "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "wd" |), "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "wd" |), "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "wd" |), "address" |) ], make_dict [] |) in @@ -1855,39 +1865,39 @@ Definition apply_body : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "withdrawals_trie" |) + M.get_name (| globals, locals_stack, "withdrawals_trie" |) ], make_dict [] |); - M.get_name (| globals, "blob_gas_used" |) + M.get_name (| globals, locals_stack, "blob_gas_used" |) ], make_dict [] |) @@ -1895,8 +1905,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1925,15 +1936,15 @@ Definition process_transaction : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1942,10 +1953,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "BlobTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |) ], make_dict [] |), @@ -1954,10 +1965,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "blob_gas_fee" , M.call (| - M.get_name (| globals, "calculate_data_fee" |), + M.get_name (| globals, locals_stack, "calculate_data_fee" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "excess_blob_gas" |); - M.get_name (| globals, "tx" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "excess_blob_gas" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1968,7 +1979,7 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "blob_gas_fee" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1980,28 +1991,28 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in @@ -2009,25 +2020,25 @@ Definition process_transaction : Value.t -> Value.t -> M := "sender_balance_after_gas_fee" , BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "effective_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "effective_gas_fee" |) |), - M.get_name (| globals, "blob_gas_fee" |) + M.get_name (| globals, locals_stack, "blob_gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2035,15 +2046,15 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -2051,10 +2062,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |); M.get_name (| globals, "BlobTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.get_name (| globals, locals_stack, "BlobTransaction" |) ] ], make_dict [] |), @@ -2062,25 +2073,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -2104,14 +2115,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2119,10 +2130,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2130,20 +2141,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 5 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -2152,17 +2163,17 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "priority_fee_per_gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |), - M.get_field (| M.get_name (| globals, "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| @@ -2170,41 +2181,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_name (| globals, "priority_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -2212,31 +2223,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -2247,20 +2258,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -2273,14 +2284,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2291,21 +2302,22 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "destroy_touched_empty_accounts" |), + M.get_name (| globals, locals_stack, "destroy_touched_empty_accounts" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |) ], make_dict [] |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -2334,14 +2346,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2349,7 +2361,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2357,7 +2369,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2371,9 +2383,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2385,20 +2397,20 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_cost" , BinOp.add (| - M.get_name (| globals, "TX_CREATE_COST" |), + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ M.call (| - M.get_name (| globals, "init_code_cost" |), + M.get_name (| globals, locals_stack, "init_code_cost" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ], make_dict [] |) @@ -2430,10 +2442,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |); M.get_name (| globals, "BlobTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.get_name (| globals, locals_stack, "BlobTransaction" |) ] ], make_dict [] |), @@ -2441,26 +2453,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -2476,17 +2488,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -2495,8 +2507,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2519,47 +2532,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2567,10 +2580,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2578,19 +2591,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2600,18 +2613,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2623,58 +2636,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2691,10 +2704,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2703,15 +2716,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2726,10 +2739,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2738,15 +2751,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_1559" |), + M.get_name (| globals, locals_stack, "signing_hash_1559" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2761,10 +2774,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "BlobTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |) ], make_dict [] |), @@ -2773,15 +2786,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_4844" |), + M.get_name (| globals, locals_stack, "signing_hash_4844" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2802,13 +2815,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2823,8 +2836,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2840,12 +2854,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2856,8 +2870,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2875,19 +2890,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2903,8 +2918,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -2920,14 +2936,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2939,8 +2955,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_1559 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 1559 signature. @@ -2956,14 +2973,14 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2975,8 +2992,9 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_4844 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP-4844 signature. @@ -2992,14 +3010,14 @@ Definition signing_hash_4844 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "03", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_blob_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "blob_versioned_hashes" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_blob_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "blob_versioned_hashes" |) ] ], make_dict [] |) @@ -3011,8 +3029,9 @@ Definition signing_hash_4844 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -3046,12 +3065,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -3062,8 +3081,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -3094,18 +3114,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3122,10 +3142,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3142,8 +3162,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( diff --git a/CoqOfPython/ethereum/cancun/fork_types.v b/CoqOfPython/ethereum/cancun/fork_types.v index dd0de4b..306871b 100644 --- a/CoqOfPython/ethereum/cancun/fork_types.v +++ b/CoqOfPython/ethereum/cancun/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.fork_types". +Definition globals : Globals.t := "ethereum.cancun.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,19 +44,19 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition VersionedHash : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -69,15 +71,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -86,12 +89,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/cancun/state.v b/CoqOfPython/ethereum/cancun/state.v index 897c75a..26b9a8e 100644 --- a/CoqOfPython/ethereum/cancun/state.v +++ b/CoqOfPython/ethereum/cancun/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.state". +Definition globals : Globals.t := "ethereum.cancun.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -100,21 +102,23 @@ Definition TransientStorage : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "transient_storage" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "transient_storage" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -129,12 +133,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The transient storage of the transaction. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -142,7 +146,7 @@ Definition begin_transaction : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "transient_storage" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_snapshots" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: DictComp *)" ], @@ -151,8 +155,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "transient_storage" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "transient_storage" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -164,18 +169,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The transient storage of the transaction. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -185,15 +190,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "transient_storage" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "transient_storage" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "transient_storage" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -206,9 +212,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The transient storage of the transaction. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -216,11 +222,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -230,9 +236,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "transient_storage" |), "_tries" |), + M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_tries" |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "transient_storage" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -240,8 +246,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -264,10 +271,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -276,31 +283,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -320,22 +328,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -350,19 +359,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -378,18 +388,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -397,8 +407,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -413,14 +424,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -430,8 +441,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -449,17 +461,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -481,9 +494,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -492,14 +505,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -514,30 +527,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -555,10 +569,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -567,9 +581,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -578,7 +592,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -586,17 +600,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -604,11 +618,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -616,14 +630,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -633,8 +647,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -650,23 +665,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -676,15 +691,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -698,13 +714,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -712,8 +728,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -732,10 +749,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -745,8 +762,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -766,10 +784,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -777,9 +795,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -788,7 +806,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -797,8 +815,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -818,10 +837,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -829,9 +848,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -841,12 +860,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -857,8 +876,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -879,10 +899,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -890,15 +910,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -908,12 +928,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -926,8 +946,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -946,10 +967,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -958,7 +979,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -972,9 +993,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -984,12 +1005,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -1002,28 +1023,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -1033,54 +1055,57 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition process_withdrawal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "wd" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "wd" ] in + ltac:(M.monadic ( let _ := Constant.str " Increase the balance of the withdrawing account. " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "wd" |), "address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "wd" |), "address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1097,19 +1122,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1125,21 +1151,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1151,8 +1177,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1166,19 +1193,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1195,19 +1223,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1226,14 +1255,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1246,18 +1275,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1266,7 +1295,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1274,7 +1303,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1287,10 +1316,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1298,21 +1327,22 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). Definition get_transient_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "transient_storage"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "transient_storage"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account from transient storage. Returns `U256(0)` if the storage key has not been set previously. @@ -1332,9 +1362,9 @@ Definition get_transient_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "transient_storage" |), "_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1343,14 +1373,14 @@ Definition get_transient_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1365,30 +1395,31 @@ Definition get_transient_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_transient_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "transient_storage"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "transient_storage"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -1406,9 +1437,9 @@ Definition set_transient_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "transient_storage" |), "_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1417,7 +1448,7 @@ Definition set_transient_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -1425,17 +1456,17 @@ Definition set_transient_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "transient_storage" |), "_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -1443,11 +1474,11 @@ Definition set_transient_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -1455,14 +1486,14 @@ Definition set_transient_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "transient_storage" |), "_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "transient_storage" |), "_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -1472,8 +1503,9 @@ Definition set_transient_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_touched_empty_accounts : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "touched_accounts" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "touched_accounts" ] in + ltac:(M.monadic ( let _ := Constant.str " Destroy all touched accounts that are empty. Parameters @@ -1485,27 +1517,27 @@ Definition destroy_touched_empty_accounts : Value.t -> Value.t -> M := " in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_name (| globals, "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_name (| globals, locals_stack, "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/cancun/transactions.v b/CoqOfPython/ethereum/cancun/transactions.v index e5e186a..960718c 100644 --- a/CoqOfPython/ethereum/cancun/transactions.v +++ b/CoqOfPython/ethereum/cancun/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.transactions". +Definition globals : Globals.t := "ethereum.cancun.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -109,14 +111,15 @@ Definition BlobTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |); M.get_name (| globals, "BlobTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.get_name (| globals, locals_stack, "BlobTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -124,17 +127,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -143,10 +146,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -156,9 +159,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -171,10 +174,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -184,9 +187,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -199,10 +202,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "BlobTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |) ], make_dict [] |), @@ -212,9 +215,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "03", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -224,7 +227,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -241,8 +244,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -250,10 +254,10 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), @@ -264,7 +268,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 @@ -273,11 +277,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -294,7 +298,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 2 @@ -303,11 +307,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "FeeMarketTransaction" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -324,7 +328,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 3 @@ -333,11 +337,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "BlobTransaction" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -349,7 +353,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ @@ -360,7 +364,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/cancun/trie.v b/CoqOfPython/ethereum/cancun/trie.v index ef7de86..45253b2 100644 --- a/CoqOfPython/ethereum/cancun/trie.v +++ b/CoqOfPython/ethereum/cancun/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.trie". +Definition globals : Globals.t := "ethereum.cancun.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -91,10 +93,10 @@ Axiom ethereum_cancun_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -107,14 +109,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); M.get_name (| globals, "Withdrawal" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); M.get_name (| globals, locals_stack, "Withdrawal" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -124,41 +126,41 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Withdrawal" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Withdrawal" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -196,14 +198,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -227,7 +230,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -243,10 +246,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -255,13 +258,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -270,10 +273,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -282,13 +285,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -297,10 +300,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -309,9 +312,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -319,7 +322,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -336,9 +339,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -348,9 +351,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -359,16 +362,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -378,8 +381,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -389,25 +393,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -419,10 +423,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Withdrawal" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Withdrawal" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -430,13 +434,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -451,27 +455,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -495,8 +499,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -513,14 +518,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -531,8 +536,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -552,8 +558,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -561,14 +567,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -580,18 +586,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -611,10 +618,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -622,21 +629,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -649,11 +657,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -661,12 +669,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -674,7 +682,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -689,9 +697,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -699,8 +707,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -737,7 +746,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -748,9 +757,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -761,13 +770,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -775,15 +784,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -793,20 +802,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -824,7 +833,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -832,13 +841,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -847,15 +856,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -865,20 +874,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -896,9 +905,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -906,8 +915,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -924,14 +934,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -942,26 +952,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -969,17 +979,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -991,9 +1001,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -1001,8 +1011,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1023,9 +1034,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1034,25 +1045,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1060,13 +1071,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1080,9 +1091,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1090,13 +1101,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1104,15 +1115,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1122,22 +1133,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1146,13 +1157,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1173,10 +1185,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1184,14 +1196,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1209,12 +1221,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1227,12 +1239,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1244,18 +1256,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1265,8 +1277,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1290,9 +1303,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1311,12 +1324,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1329,9 +1342,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1342,24 +1355,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1369,8 +1382,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1378,31 +1391,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1417,7 +1430,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1438,7 +1451,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1446,30 +1459,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1489,9 +1502,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1499,7 +1512,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1517,21 +1530,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1539,19 +1552,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1560,8 +1573,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1570,17 +1583,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1593,10 +1606,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/utils/__init__.v b/CoqOfPython/ethereum/cancun/utils/__init__.v index 3e26e47..79ec750 100644 --- a/CoqOfPython/ethereum/cancun/utils/__init__.v +++ b/CoqOfPython/ethereum/cancun/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.utils.__init__". +Definition globals : Globals.t := "ethereum.cancun.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/cancun/utils/address.v b/CoqOfPython/ethereum/cancun/utils/address.v index c9e2edc..4cc1454 100644 --- a/CoqOfPython/ethereum/cancun/utils/address.v +++ b/CoqOfPython/ethereum/cancun/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.utils.address". +Definition globals : Globals.t := "ethereum.cancun.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_cancun_fork_types_imports_Address : IsImported globals "ethereum.cancun.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/utils/hexadecimal.v b/CoqOfPython/ethereum/cancun/utils/hexadecimal.v index 8834108..dd5a681 100644 --- a/CoqOfPython/ethereum/cancun/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/cancun/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.cancun.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_cancun_fork_types_imports_Root : IsImported globals "ethereum.cancun.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/cancun/utils/message.v b/CoqOfPython/ethereum/cancun/utils/message.v index e62d563..b55ae28 100644 --- a/CoqOfPython/ethereum/cancun/utils/message.v +++ b/CoqOfPython/ethereum/cancun/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.utils.message". +Definition globals : Globals.t := "ethereum.cancun.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_cancun_utils_address_imports_compute_contract_address : IsImported globals "ethereum.cancun.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/__init__.v b/CoqOfPython/ethereum/cancun/vm/__init__.v index 5efb61d..c02cc0a 100644 --- a/CoqOfPython/ethereum/cancun/vm/__init__.v +++ b/CoqOfPython/ethereum/cancun/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.__init__". +Definition globals : Globals.t := "ethereum.cancun.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -101,8 +103,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -115,30 +118,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -146,19 +149,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -168,24 +171,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -200,15 +204,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -221,8 +225,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -230,19 +234,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -258,7 +262,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/exceptions.v b/CoqOfPython/ethereum/cancun/vm/exceptions.v index 42aba40..257d805 100644 --- a/CoqOfPython/ethereum/cancun/vm/exceptions.v +++ b/CoqOfPython/ethereum/cancun/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.exceptions". +Definition globals : Globals.t := "ethereum.cancun.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/cancun/vm/gas.v b/CoqOfPython/ethereum/cancun/vm/gas.v index 8e04e69..e2a9141 100644 --- a/CoqOfPython/ethereum/cancun/vm/gas.v +++ b/CoqOfPython/ethereum/cancun/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.gas". +Definition globals : Globals.t := "ethereum.cancun.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -58,7 +60,7 @@ Axiom ethereum_cancun_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -68,7 +70,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -78,7 +80,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -88,7 +90,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -98,7 +100,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -108,7 +110,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 4800 ], @@ -118,7 +120,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -128,7 +130,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -138,7 +140,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -148,7 +150,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -158,7 +160,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -168,7 +170,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -178,7 +180,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -188,7 +190,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -198,7 +200,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -208,7 +210,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -218,7 +220,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -228,7 +230,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -238,7 +240,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -248,7 +250,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -258,7 +260,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -268,7 +270,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -278,7 +280,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -288,7 +290,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -298,7 +300,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -308,7 +310,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -318,7 +320,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -328,7 +330,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -338,7 +340,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -348,7 +350,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -358,7 +360,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -368,7 +370,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -378,7 +380,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -388,7 +390,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -398,7 +400,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -408,7 +410,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -418,7 +420,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -428,7 +430,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -438,7 +440,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -448,7 +450,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -462,7 +464,7 @@ Definition GAS_INIT_CODE_WORD_COST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOBHASH_OPCODE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -472,7 +474,7 @@ Definition GAS_BLOBHASH_OPCODE : Value.t := M.run ltac:(M.monadic ( Definition GAS_POINT_EVALUATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50000 ], @@ -482,7 +484,7 @@ Definition GAS_POINT_EVALUATION : Value.t := M.run ltac:(M.monadic ( Definition TARGET_BLOB_GAS_PER_BLOCK : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U64" |), + M.get_name (| globals, locals_stack, "U64" |), make_list [ Constant.int 393216 ], @@ -492,7 +494,7 @@ Definition TARGET_BLOB_GAS_PER_BLOCK : Value.t := M.run ltac:(M.monadic ( Definition GAS_PER_BLOB : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.pow (| Constant.int 2, @@ -505,7 +507,7 @@ Definition GAS_PER_BLOB : Value.t := M.run ltac:(M.monadic ( Definition MIN_BLOB_GASPRICE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -515,7 +517,7 @@ Definition MIN_BLOB_GASPRICE : Value.t := M.run ltac:(M.monadic ( Definition BLOB_GASPRICE_UPDATE_FRACTION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3338477 ], @@ -544,8 +546,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -558,13 +561,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -575,22 +578,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -600,8 +603,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -621,9 +625,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -633,15 +637,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -650,16 +654,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -678,7 +683,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -688,7 +693,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -698,12 +703,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -713,14 +718,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -734,9 +739,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -744,20 +749,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -770,8 +775,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -785,16 +790,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -802,9 +807,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -813,13 +818,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -829,10 +834,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -840,8 +845,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -872,13 +878,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -886,32 +892,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -925,18 +931,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -947,15 +953,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -964,8 +970,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -981,9 +988,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) @@ -991,8 +998,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition init_code_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "init_code_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "init_code_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas to be charged for the init code in CREAT* opcodes as well as create transactions. @@ -1011,11 +1019,11 @@ Definition init_code_cost : Value.t -> Value.t -> M := let _ := M.return_ (| BinOp.floor_div (| BinOp.mult (| - M.get_name (| globals, "GAS_INIT_CODE_WORD_COST" |), + M.get_name (| globals, locals_stack, "GAS_INIT_CODE_WORD_COST" |), M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "init_code_length" |) + M.get_name (| globals, locals_stack, "init_code_length" |) ], make_dict [] |) @@ -1026,8 +1034,9 @@ Definition init_code_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_excess_blob_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculated the excess blob gas for the current block based on the gas used in the parent block. @@ -1045,22 +1054,22 @@ Definition calculate_excess_blob_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_blob_gas" , BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "excess_blob_gas" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "blob_gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "excess_blob_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "blob_gas_used" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "parent_blob_gas" |), - M.get_name (| globals, "TARGET_BLOB_GAS_PER_BLOCK" |) + M.get_name (| globals, locals_stack, "parent_blob_gas" |), + M.get_name (| globals, locals_stack, "TARGET_BLOB_GAS_PER_BLOCK" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U64" |), + M.get_name (| globals, locals_stack, "U64" |), make_list [ Constant.int 0 ], @@ -1072,8 +1081,8 @@ Definition calculate_excess_blob_gas : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "parent_blob_gas" |), - M.get_name (| globals, "TARGET_BLOB_GAS_PER_BLOCK" |) + M.get_name (| globals, locals_stack, "parent_blob_gas" |), + M.get_name (| globals, locals_stack, "TARGET_BLOB_GAS_PER_BLOCK" |) |) |) in M.pure Constant.None_ @@ -1081,8 +1090,9 @@ Definition calculate_excess_blob_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_total_blob_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the total blob gas for a transaction. @@ -1100,10 +1110,10 @@ Definition calculate_total_blob_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "BlobTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "BlobTransaction" |) ], make_dict [] |), @@ -1111,11 +1121,11 @@ Definition calculate_total_blob_gas : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| BinOp.mult (| - M.get_name (| globals, "GAS_PER_BLOB" |), + M.get_name (| globals, locals_stack, "GAS_PER_BLOB" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "blob_versioned_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "blob_versioned_hashes" |) ], make_dict [] |) @@ -1126,7 +1136,7 @@ Definition calculate_total_blob_gas : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1138,8 +1148,9 @@ Definition calculate_total_blob_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_blob_gas_price : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "excess_blob_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "excess_blob_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the blob gasprice for a block. @@ -1155,17 +1166,17 @@ Definition calculate_blob_gas_price : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "taylor_exponential" |), + M.get_name (| globals, locals_stack, "taylor_exponential" |), make_list [ - M.get_name (| globals, "MIN_BLOB_GASPRICE" |); + M.get_name (| globals, locals_stack, "MIN_BLOB_GASPRICE" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "excess_blob_gas" |) + M.get_name (| globals, locals_stack, "excess_blob_gas" |) ], make_dict [] |); - M.get_name (| globals, "BLOB_GASPRICE_UPDATE_FRACTION" |) + M.get_name (| globals, locals_stack, "BLOB_GASPRICE_UPDATE_FRACTION" |) ], make_dict [] |) @@ -1173,8 +1184,9 @@ Definition calculate_blob_gas_price : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_data_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "excess_blob_gas"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "excess_blob_gas"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the blob data fee for a transaction. @@ -1193,16 +1205,16 @@ Definition calculate_data_fee : Value.t -> Value.t -> M := let _ := M.return_ (| BinOp.mult (| M.call (| - M.get_name (| globals, "calculate_total_blob_gas" |), + M.get_name (| globals, locals_stack, "calculate_total_blob_gas" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "calculate_blob_gas_price" |), + M.get_name (| globals, locals_stack, "calculate_blob_gas_price" |), make_list [ - M.get_name (| globals, "excess_blob_gas" |) + M.get_name (| globals, locals_stack, "excess_blob_gas" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/__init__.v b/CoqOfPython/ethereum/cancun/vm/instructions/__init__.v index 0523587..153a2a3 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/cancun/vm/instructions/arithmetic.v index dc9d022..841636b 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/bitwise.v b/CoqOfPython/ethereum/cancun/vm/instructions/bitwise.v index 3a02f86..63df69c 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/block.v b/CoqOfPython/ethereum/cancun/vm/instructions/block.v index f0c6cb2..7c09d92 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/block.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.block". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -57,18 +60,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -77,14 +80,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -102,23 +105,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -127,14 +130,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -156,21 +160,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -179,14 +183,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -208,31 +213,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -253,21 +259,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -276,14 +282,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition prev_randao : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the `prev_randao` value onto the stack. @@ -304,21 +311,21 @@ Definition prev_randao : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "prev_randao" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "prev_randao" |) ], make_dict [] |) @@ -327,14 +334,15 @@ Definition prev_randao : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -355,21 +363,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -378,14 +386,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -403,21 +412,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -426,7 +435,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/comparison.v b/CoqOfPython/ethereum/cancun/vm/instructions/comparison.v index a80ba14..645ec45 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/control_flow.v b/CoqOfPython/ethereum/cancun/vm/instructions/control_flow.v index ac1ba96..b659a5e 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/environment.v b/CoqOfPython/ethereum/cancun/vm/instructions/environment.v index ab22c8e..abac4b4 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -82,8 +84,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -95,21 +98,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -118,14 +121,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -138,12 +142,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -155,16 +159,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -172,17 +176,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -191,32 +195,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -229,21 +234,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -252,14 +257,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -271,21 +277,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -294,14 +300,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -313,31 +320,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -351,30 +359,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -385,13 +393,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -400,14 +408,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -419,24 +428,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -448,14 +457,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -471,9 +481,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -481,9 +491,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,9 +501,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -502,12 +512,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -520,76 +530,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -601,24 +612,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -630,14 +641,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -653,9 +665,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -663,9 +675,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -673,9 +685,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -684,12 +696,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -702,76 +714,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -783,21 +796,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -806,14 +819,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -826,12 +840,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,16 +857,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -860,17 +874,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -879,16 +893,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -900,23 +914,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -929,12 +944,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -945,9 +960,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -955,9 +970,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -965,9 +980,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -976,12 +991,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -994,18 +1009,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1015,21 +1030,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1038,22 +1053,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1062,19 +1077,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1082,34 +1097,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1120,24 +1136,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1149,14 +1165,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1168,9 +1185,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1178,9 +1195,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1188,9 +1205,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1199,12 +1216,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1217,108 +1234,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1329,12 +1347,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1346,16 +1364,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1363,17 +1381,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1382,10 +1400,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1394,15 +1412,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1415,12 +1433,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1431,23 +1449,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1459,42 +1478,43 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the base fee of the current block on to the stack. @@ -1506,21 +1526,21 @@ Definition base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "base_fee_per_gas" |) ], make_dict [] |) @@ -1529,14 +1549,15 @@ Definition base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition blob_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the versioned hash at a particular index on to the stack. @@ -1549,18 +1570,18 @@ Definition blob_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOBHASH_OPCODE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOBHASH_OPCODE" |) ], make_dict [] |) in @@ -1568,11 +1589,11 @@ Definition blob_hash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "index" |), + M.get_name (| globals, locals_stack, "index" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "blob_versioned_hashes" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "blob_versioned_hashes" |) ], make_dict [] |) @@ -1582,8 +1603,8 @@ Definition blob_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "blob_hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "blob_versioned_hashes" |), - M.get_name (| globals, "index" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "blob_versioned_hashes" |), + M.get_name (| globals, locals_stack, "index" |) |) |) in M.pure Constant.None_ @@ -1592,7 +1613,7 @@ Definition blob_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "blob_hash" , M.call (| - M.get_name (| globals, "Bytes32" |), + M.get_name (| globals, locals_stack, "Bytes32" |), make_list [ BinOp.mult (| Constant.bytes "00", @@ -1605,13 +1626,13 @@ Definition blob_hash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "blob_hash" |) + M.get_name (| globals, locals_stack, "blob_hash" |) ], make_dict [] |) @@ -1620,14 +1641,15 @@ Definition blob_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition blob_base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the blob base fee on to the stack. @@ -1639,31 +1661,31 @@ Definition blob_base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.assign_local (| "blob_base_fee" , M.call (| - M.get_name (| globals, "calculate_blob_gas_price" |), + M.get_name (| globals, locals_stack, "calculate_blob_gas_price" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "excess_blob_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "excess_blob_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "blob_base_fee" |) + M.get_name (| globals, locals_stack, "blob_base_fee" |) ], make_dict [] |) @@ -1672,7 +1694,7 @@ Definition blob_base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/keccak.v b/CoqOfPython/ethereum/cancun/vm/instructions/keccak.v index 03a31d2..4951ae6 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/log.v b/CoqOfPython/ethereum/cancun/vm/instructions/log.v index cfc4c02..21566ee 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/log.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.log". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_cancun_vm_stack_imports_pop : IsImported globals "ethereum.cancun.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/memory.v b/CoqOfPython/ethereum/cancun/vm/instructions/memory.v index acd8e09..876eba1 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -52,8 +54,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -68,9 +71,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -79,9 +82,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -92,17 +95,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -115,43 +118,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -166,9 +170,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -176,9 +180,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -186,12 +190,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -203,32 +207,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -237,24 +241,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -267,9 +272,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -277,12 +282,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -294,36 +299,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -337,23 +342,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -365,24 +371,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -394,14 +400,15 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mcopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy the bytes in memory from one location to another. @@ -414,9 +421,9 @@ Definition mcopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -424,9 +431,9 @@ Definition mcopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "source" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -434,9 +441,9 @@ Definition mcopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "length" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -445,12 +452,12 @@ Definition mcopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "length" |) + M.get_name (| globals, locals_stack, "length" |) ], make_dict [] |) @@ -463,70 +470,70 @@ Definition mcopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "source" |); M.get_name (| globals, "length" |) ]; - make_tuple [ M.get_name (| globals, "destination" |); M.get_name (| globals, "length" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "source" |); M.get_name (| globals, locals_stack, "length" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "destination" |); M.get_name (| globals, locals_stack, "length" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "source" |); - M.get_name (| globals, "length" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "source" |); + M.get_name (| globals, locals_stack, "length" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "destination" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "destination" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/stack.v b/CoqOfPython/ethereum/cancun/vm/instructions/stack.v index aec7b04..6cf72ee 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_cancun_vm_memory_imports_buffer_read : IsImported globals "ethereum.cancun.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. Push zero if num_bytes is zero. @@ -100,16 +104,16 @@ Definition push_n : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "num_bytes" |), + M.get_name (| globals, locals_stack, "num_bytes" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in @@ -117,10 +121,10 @@ Definition push_n : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -129,26 +133,26 @@ Definition push_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -160,26 +164,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -195,67 +200,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -275,64 +281,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -340,9 +346,9 @@ Definition push0 : Value.t := M.run ltac:(M.monadic ( Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -350,9 +356,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -360,9 +366,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -370,9 +376,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -380,9 +386,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -390,9 +396,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -400,9 +406,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -410,9 +416,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -420,9 +426,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -430,9 +436,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -440,9 +446,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -450,9 +456,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -460,9 +466,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -470,9 +476,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -480,9 +486,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -490,9 +496,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -500,9 +506,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -510,9 +516,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -520,9 +526,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -530,9 +536,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -540,9 +546,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -550,9 +556,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -560,9 +566,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -570,9 +576,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -580,9 +586,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -590,9 +596,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -600,9 +606,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -610,9 +616,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -620,9 +626,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -630,9 +636,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -640,9 +646,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -650,9 +656,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -660,9 +666,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -670,9 +676,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -680,9 +686,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -690,9 +696,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -700,9 +706,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -710,9 +716,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -720,9 +726,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -730,9 +736,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -740,9 +746,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -750,9 +756,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -760,9 +766,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -770,9 +776,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -780,9 +786,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -790,9 +796,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -800,9 +806,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -810,9 +816,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -820,9 +826,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -830,9 +836,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -840,9 +846,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -850,9 +856,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -860,9 +866,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -870,9 +876,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -880,9 +886,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -890,9 +896,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -900,9 +906,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -910,9 +916,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -920,9 +926,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -930,9 +936,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -940,9 +946,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -950,9 +956,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -960,9 +966,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -970,9 +976,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/storage.v b/CoqOfPython/ethereum/cancun/vm/instructions/storage.v index 04025e4..1043ae7 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -63,8 +65,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -79,9 +82,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -93,16 +96,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -110,17 +113,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -129,33 +132,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -169,9 +173,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -182,32 +186,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -215,11 +219,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -227,7 +231,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -238,22 +242,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -265,13 +269,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -281,7 +285,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -289,7 +293,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -298,8 +302,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -310,7 +314,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -318,8 +322,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -328,18 +332,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -350,11 +354,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -369,12 +373,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -383,11 +387,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -401,8 +405,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -410,20 +414,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -434,16 +438,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -462,41 +466,42 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition tload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the transient storage of the current account. @@ -509,9 +514,9 @@ Definition tload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -520,43 +525,44 @@ Definition tload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_transient_storage" |), + M.get_name (| globals, locals_stack, "get_transient_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "transient_storage" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "transient_storage" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition tstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's transient storage. Parameters @@ -568,9 +574,9 @@ Definition tstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -581,42 +587,42 @@ Definition tstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_transient_storage" |), + M.get_name (| globals, locals_stack, "set_transient_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "transient_storage" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "transient_storage" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/instructions/system.v b/CoqOfPython/ethereum/cancun/vm/instructions/system.v index 07121d5..3ef8d6f 100644 --- a/CoqOfPython/ethereum/cancun/vm/instructions/system.v +++ b/CoqOfPython/ethereum/cancun/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.instructions.system". +Definition globals : Globals.t := "ethereum.cancun.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -111,8 +113,9 @@ Axiom ethereum_cancun_vm_stack_imports_push : IsImported globals "ethereum.cancun.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size"; "init_code_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size"; "init_code_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in @@ -120,51 +123,51 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |), BinOp.mult (| Constant.int 2, - M.get_name (| globals, "MAX_CODE_SIZE" |) + M.get_name (| globals, locals_stack, "MAX_CODE_SIZE" |) |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -174,32 +177,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -209,15 +212,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -233,10 +236,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -246,15 +249,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -275,29 +278,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -315,17 +318,17 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -333,10 +336,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -344,27 +347,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -377,25 +380,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -407,8 +410,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -420,9 +424,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -430,9 +434,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -440,9 +444,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -450,11 +454,11 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -463,12 +467,12 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "init_code_gas" , M.call (| - M.get_name (| globals, "init_code_cost" |), + M.get_name (| globals, locals_stack, "init_code_cost" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -477,38 +481,38 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |), - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "init_code_gas" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -517,27 +521,28 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |); - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |); + M.get_name (| globals, locals_stack, "init_code_gas" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -552,9 +557,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -562,9 +567,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -572,9 +577,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -583,9 +588,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -596,11 +601,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -610,12 +615,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -628,12 +633,12 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "init_code_gas" , M.call (| - M.get_name (| globals, "init_code_cost" |), + M.get_name (| globals, locals_stack, "init_code_cost" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -642,46 +647,46 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |), - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "init_code_gas" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -690,27 +695,28 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |); - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |); + M.get_name (| globals, locals_stack, "init_code_gas" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -722,9 +728,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -732,9 +738,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -742,63 +748,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -806,24 +813,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -843,11 +850,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -855,10 +862,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -866,7 +873,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -874,10 +881,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -885,27 +892,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -918,23 +925,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -948,16 +955,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -969,14 +976,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -985,8 +992,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -998,12 +1006,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1014,12 +1022,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1030,9 +1038,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1040,9 +1048,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1050,9 +1058,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1060,9 +1068,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1070,9 +1078,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1080,12 +1088,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1095,28 +1103,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1126,16 +1134,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1143,7 +1151,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1151,7 +1159,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1159,13 +1167,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1173,56 +1181,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1231,25 +1239,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1258,17 +1266,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1278,32 +1286,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1311,14 +1319,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1330,12 +1339,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1346,12 +1355,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1362,9 +1371,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1372,9 +1381,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1382,9 +1391,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1392,9 +1401,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1402,26 +1411,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1431,28 +1440,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1461,13 +1470,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1475,58 +1484,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1535,17 +1544,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1555,32 +1564,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1588,14 +1597,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1607,12 +1617,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1622,28 +1632,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1655,20 +1665,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1681,7 +1691,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1689,43 +1699,43 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); - M.get_name (| globals, "beneficiary" |); - M.get_name (| globals, "originator_balance" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); + M.get_name (| globals, locals_stack, "beneficiary" |); + M.get_name (| globals, locals_stack, "originator_balance" |) ], make_dict [] |) in @@ -1733,18 +1743,18 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "originator" |), - M.get_field (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |), "created_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_field (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |), "created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1754,9 +1764,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1769,19 +1779,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1791,15 +1801,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1811,12 +1822,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1827,12 +1838,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1843,9 +1854,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1853,9 +1864,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1863,9 +1874,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1873,9 +1884,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1883,12 +1894,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1898,104 +1909,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -2007,12 +2019,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2023,12 +2035,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2039,9 +2051,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2049,9 +2061,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2059,9 +2071,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2069,9 +2081,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2079,12 +2091,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2094,110 +2106,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2209,9 +2222,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2219,9 +2232,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2229,54 +2242,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/interpreter.v b/CoqOfPython/ethereum/cancun/vm/interpreter.v index c3551ef..cb7f0df 100644 --- a/CoqOfPython/ethereum/cancun/vm/interpreter.v +++ b/CoqOfPython/ethereum/cancun/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.interpreter". +Definition globals : Globals.t := "ethereum.cancun.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -128,7 +130,7 @@ Axiom ethereum_cancun_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -151,8 +153,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -174,9 +177,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -188,10 +191,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -199,44 +202,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -250,10 +253,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -266,10 +269,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -278,13 +281,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -294,12 +297,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -316,14 +319,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -331,7 +334,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -339,7 +342,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,22 +354,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -376,29 +379,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -406,8 +409,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -424,44 +428,44 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "transient_storage" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "transient_storage" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -469,24 +473,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -494,23 +498,24 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "transient_storage" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "transient_storage" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -530,13 +535,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -548,18 +553,18 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "transient_storage" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "transient_storage" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -567,10 +572,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -578,12 +583,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -595,10 +600,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -606,14 +611,14 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "transient_storage" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "transient_storage" |) ], make_dict [] |) in @@ -621,23 +626,24 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "transient_storage" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "transient_storage" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -655,14 +661,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -670,13 +676,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/memory.v b/CoqOfPython/ethereum/cancun/vm/memory.v index 71fb1d2..8c8d7b2 100644 --- a/CoqOfPython/ethereum/cancun/vm/memory.v +++ b/CoqOfPython/ethereum/cancun/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.memory". +Definition globals : Globals.t := "ethereum.cancun.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/__init__.v index dbf6f8a..643851e 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], @@ -117,7 +119,7 @@ Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition POINT_EVALUATION_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x0a" ], diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/alt_bn128.v index ec05c60..53fc9cd 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_cancun_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.cancun.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/blake2f.v index 9f5c33f..cf7db0e 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_cancun_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.cancun.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ecrecover.v index e169b9c..399b13b 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_cancun_vm_memory_imports_buffer_read : IsImported globals "ethereum.cancun.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/identity.v index bedd17c..8289b55 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_cancun_vm_gas_imports_charge_gas : IsImported globals "ethereum.cancun.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/mapping.v index e780b97..cb5ae03 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/modexp.v index ec4e35a..aa48ec1 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/point_evaluation.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/point_evaluation.v index 4b6a5a2..857f687 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/point_evaluation.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/point_evaluation.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.point_evaluation". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.point_evaluation". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Definition VERSIONED_HASH_VERSION_KZG : Value.t := M.run ltac:(M.monadic ( )). Definition point_evaluation : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " A pre-compile that verifies a KZG proof which claims that a blob (represented by a commitment) evaluates to a given value at a given point. @@ -70,29 +73,29 @@ Definition point_evaluation : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 192 |); - M.get_name (| globals, "KZGProofError" |) + M.get_name (| globals, locals_stack, "KZGProofError" |) ], make_dict [] |) in let _ := M.assign_local (| "versioned_hash" , M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.None_, Constant.int 32, Constant.None_ @@ -101,7 +104,7 @@ Definition point_evaluation : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.int 32, Constant.int 64, Constant.None_ @@ -110,7 +113,7 @@ Definition point_evaluation : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.int 64, Constant.int 96, Constant.None_ @@ -119,10 +122,10 @@ Definition point_evaluation : Value.t -> Value.t -> M := let _ := M.assign_local (| "commitment" , M.call (| - M.get_name (| globals, "KZGCommitment" |), + M.get_name (| globals, locals_stack, "KZGCommitment" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.int 96, Constant.int 144, Constant.None_ @@ -134,57 +137,57 @@ Definition point_evaluation : Value.t -> Value.t -> M := let _ := M.assign_local (| "proof" , M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.int 144, Constant.int 192, Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_POINT_EVALUATION" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_POINT_EVALUATION" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "kzg_commitment_to_versioned_hash" |), + M.get_name (| globals, locals_stack, "kzg_commitment_to_versioned_hash" |), make_list [ - M.get_name (| globals, "commitment" |) + M.get_name (| globals, locals_stack, "commitment" |) ], make_dict [] |), - M.get_name (| globals, "versioned_hash" |) + M.get_name (| globals, locals_stack, "versioned_hash" |) |); - M.get_name (| globals, "KZGProofError" |) + M.get_name (| globals, locals_stack, "KZGProofError" |) ], make_dict [] |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - M.get_name (| globals, "kzg_proof_verification" |); - M.get_name (| globals, "KZGProofError" |) + M.get_name (| globals, locals_stack, "kzg_proof_verification" |); + M.get_name (| globals, locals_stack, "KZGProofError" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ BinOp.add (| M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "FIELD_ELEMENTS_PER_BLOB" |) + M.get_name (| globals, locals_stack, "FIELD_ELEMENTS_PER_BLOB" |) ], make_dict [] |), "to_be_bytes32" |), @@ -193,9 +196,9 @@ Definition point_evaluation : Value.t -> Value.t -> M := |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "BLS_MODULUS" |) + M.get_name (| globals, locals_stack, "BLS_MODULUS" |) ], make_dict [] |), "to_be_bytes32" |), diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ripemd160.v index 18c8614..9b8920d 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_cancun_vm_gas_imports_charge_gas : IsImported globals "ethereum.cancun.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/sha256.v index fe7ed42..383000d 100644 --- a/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/cancun/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.cancun.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_cancun_vm_gas_imports_charge_gas : IsImported globals "ethereum.cancun.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/cancun/vm/runtime.v b/CoqOfPython/ethereum/cancun/vm/runtime.v index 5c08753..1b9c307 100644 --- a/CoqOfPython/ethereum/cancun/vm/runtime.v +++ b/CoqOfPython/ethereum/cancun/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.runtime". +Definition globals : Globals.t := "ethereum.cancun.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_cancun_vm_instructions_imports_Ops : IsImported globals "ethereum.cancun.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/cancun/vm/stack.v b/CoqOfPython/ethereum/cancun/vm/stack.v index 8c8a63b..d284bd8 100644 --- a/CoqOfPython/ethereum/cancun/vm/stack.v +++ b/CoqOfPython/ethereum/cancun/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.cancun.vm.stack". +Definition globals : Globals.t := "ethereum.cancun.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_cancun_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.cancun.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/__init__.v b/CoqOfPython/ethereum/constantinople/__init__.v index 4727e2a..630e0ed 100644 --- a/CoqOfPython/ethereum/constantinople/__init__.v +++ b/CoqOfPython/ethereum/constantinople/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.__init__". +Definition globals : Globals.t := "ethereum.constantinople.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -14,7 +16,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 7280000 ], diff --git a/CoqOfPython/ethereum/constantinople/blocks.v b/CoqOfPython/ethereum/constantinople/blocks.v index e6c6eb3..ffb89c6 100644 --- a/CoqOfPython/ethereum/constantinople/blocks.v +++ b/CoqOfPython/ethereum/constantinople/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.blocks". +Definition globals : Globals.t := "ethereum.constantinople.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/constantinople/bloom.v b/CoqOfPython/ethereum/constantinople/bloom.v index a432ffc..a7f9abc 100644 --- a/CoqOfPython/ethereum/constantinople/bloom.v +++ b/CoqOfPython/ethereum/constantinople/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.bloom". +Definition globals : Globals.t := "ethereum.constantinople.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_constantinople_fork_types_imports_Bloom : IsImported globals "ethereum.constantinople.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/fork.v b/CoqOfPython/ethereum/constantinople/fork.v index 06668fb..7459441 100644 --- a/CoqOfPython/ethereum/constantinople/fork.v +++ b/CoqOfPython/ethereum/constantinople/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.fork". +Definition globals : Globals.t := "ethereum.constantinople.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -134,7 +136,7 @@ Axiom ethereum_constantinople_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -158,7 +160,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -176,10 +178,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -201,8 +203,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -222,13 +225,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -251,7 +255,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -262,9 +266,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -286,17 +290,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -309,13 +313,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -326,20 +330,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -364,111 +369,111 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -477,9 +482,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -488,9 +493,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -504,8 +509,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -526,101 +532,101 @@ Definition validate_header : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -629,28 +635,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -676,26 +683,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -703,8 +710,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -722,9 +730,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -732,25 +740,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -759,41 +767,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -817,35 +826,36 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -869,13 +879,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -890,8 +900,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -934,51 +945,51 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -986,18 +997,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1005,49 +1016,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1056,56 +1067,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1116,8 +1127,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1142,27 +1154,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1171,9 +1183,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1191,46 +1203,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1241,19 +1253,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1262,23 +1274,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1286,16 +1298,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1309,13 +1321,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1330,11 +1342,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1342,88 +1354,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1436,8 +1448,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1466,44 +1479,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1515,19 +1528,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1540,8 +1553,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1569,30 +1583,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1600,98 +1614,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1699,10 +1713,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1710,20 +1724,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1732,10 +1746,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1743,41 +1757,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1785,31 +1799,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1820,20 +1834,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1846,14 +1860,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1865,27 +1879,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1901,13 +1915,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1936,17 +1951,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1961,8 +1976,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1991,14 +2007,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2006,7 +2022,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2014,7 +2030,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2028,9 +2044,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2041,7 +2057,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2054,14 +2070,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -2070,8 +2086,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2094,47 +2111,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2143,12 +2160,12 @@ Definition recover_sender : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2158,18 +2175,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2181,58 +2198,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2244,13 +2261,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2265,8 +2282,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2282,12 +2300,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2298,8 +2316,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2317,19 +2336,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2345,8 +2364,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2380,12 +2400,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2396,8 +2416,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2428,18 +2449,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2456,10 +2477,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2476,8 +2497,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2495,8 +2516,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2540,21 +2562,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -2564,11 +2586,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2586,13 +2608,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2601,13 +2623,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -2618,7 +2640,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2628,7 +2650,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2638,13 +2660,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/fork_types.v b/CoqOfPython/ethereum/constantinople/fork_types.v index 351e1ef..b0fd4d6 100644 --- a/CoqOfPython/ethereum/constantinople/fork_types.v +++ b/CoqOfPython/ethereum/constantinople/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.fork_types". +Definition globals : Globals.t := "ethereum.constantinople.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/constantinople/state.v b/CoqOfPython/ethereum/constantinople/state.v index 15a1a6d..c3780db 100644 --- a/CoqOfPython/ethereum/constantinople/state.v +++ b/CoqOfPython/ethereum/constantinople/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.state". +Definition globals : Globals.t := "ethereum.constantinople.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,8 +710,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -714,10 +732,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -725,9 +743,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -737,12 +755,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -753,8 +771,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -775,10 +794,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -786,15 +805,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -804,12 +823,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -822,8 +841,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -842,10 +862,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -854,7 +874,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -868,9 +888,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -880,12 +900,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -898,28 +918,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -929,36 +950,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -975,19 +998,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1003,21 +1027,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1029,8 +1053,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1044,19 +1069,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1073,19 +1099,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1100,11 +1127,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/constantinople/transactions.v b/CoqOfPython/ethereum/constantinople/transactions.v index e2158f5..c4232b6 100644 --- a/CoqOfPython/ethereum/constantinople/transactions.v +++ b/CoqOfPython/ethereum/constantinople/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.transactions". +Definition globals : Globals.t := "ethereum.constantinople.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/constantinople/trie.v b/CoqOfPython/ethereum/constantinople/trie.v index 18f9155..61ed486 100644 --- a/CoqOfPython/ethereum/constantinople/trie.v +++ b/CoqOfPython/ethereum/constantinople/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.trie". +Definition globals : Globals.t := "ethereum.constantinople.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_constantinople_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/utils/__init__.v b/CoqOfPython/ethereum/constantinople/utils/__init__.v index e5396b1..4a1852f 100644 --- a/CoqOfPython/ethereum/constantinople/utils/__init__.v +++ b/CoqOfPython/ethereum/constantinople/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.utils.__init__". +Definition globals : Globals.t := "ethereum.constantinople.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/constantinople/utils/address.v b/CoqOfPython/ethereum/constantinople/utils/address.v index a23e9b8..d255ebe 100644 --- a/CoqOfPython/ethereum/constantinople/utils/address.v +++ b/CoqOfPython/ethereum/constantinople/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.utils.address". +Definition globals : Globals.t := "ethereum.constantinople.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_constantinople_fork_types_imports_Address : IsImported globals "ethereum.constantinople.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/utils/hexadecimal.v b/CoqOfPython/ethereum/constantinople/utils/hexadecimal.v index 6eae082..04eb76a 100644 --- a/CoqOfPython/ethereum/constantinople/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/constantinople/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.constantinople.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_constantinople_fork_types_imports_Root : IsImported globals "ethereum.constantinople.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/constantinople/utils/message.v b/CoqOfPython/ethereum/constantinople/utils/message.v index 202ca4d..6c0733c 100644 --- a/CoqOfPython/ethereum/constantinople/utils/message.v +++ b/CoqOfPython/ethereum/constantinople/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.utils.message". +Definition globals : Globals.t := "ethereum.constantinople.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_constantinople_utils_address_imports_compute_contract_address : IsImported globals "ethereum.constantinople.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -85,10 +88,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -97,20 +100,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -124,7 +127,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -133,7 +136,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -142,10 +145,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -153,19 +156,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -174,14 +177,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -192,7 +195,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -204,7 +207,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/vm/__init__.v b/CoqOfPython/ethereum/constantinople/vm/__init__.v index 73a0539..c15b0e0 100644 --- a/CoqOfPython/ethereum/constantinople/vm/__init__.v +++ b/CoqOfPython/ethereum/constantinople/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.__init__". +Definition globals : Globals.t := "ethereum.constantinople.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -93,8 +95,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -107,30 +110,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -138,19 +141,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -162,8 +165,9 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -178,15 +182,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -199,8 +203,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -208,19 +212,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -236,7 +240,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/exceptions.v b/CoqOfPython/ethereum/constantinople/vm/exceptions.v index 6a2283c..e9b6a3e 100644 --- a/CoqOfPython/ethereum/constantinople/vm/exceptions.v +++ b/CoqOfPython/ethereum/constantinople/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.exceptions". +Definition globals : Globals.t := "ethereum.constantinople.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/constantinople/vm/gas.v b/CoqOfPython/ethereum/constantinople/vm/gas.v index 7a776c8..a06b70c 100644 --- a/CoqOfPython/ethereum/constantinople/vm/gas.v +++ b/CoqOfPython/ethereum/constantinople/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.gas". +Definition globals : Globals.t := "ethereum.constantinople.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_constantinople_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -86,7 +88,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -116,7 +118,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -126,7 +128,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -136,7 +138,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -166,7 +168,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -176,7 +178,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -196,7 +198,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -206,7 +208,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -216,7 +218,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -226,7 +228,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 400 ], @@ -236,7 +238,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -246,7 +248,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -256,7 +258,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -266,7 +268,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -276,7 +278,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -286,7 +288,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -296,7 +298,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -306,7 +308,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -326,7 +328,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -336,7 +338,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -346,7 +348,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -356,7 +358,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -366,7 +368,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -376,7 +378,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -386,7 +388,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -396,7 +398,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -406,7 +408,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -416,7 +418,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -426,7 +428,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -436,7 +438,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -446,7 +448,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 400 ], @@ -475,8 +477,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -489,13 +492,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -506,22 +509,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -531,8 +534,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -552,9 +556,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -564,15 +568,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -581,16 +585,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,7 +624,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -629,12 +634,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -644,14 +649,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -665,9 +670,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -675,20 +680,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -701,8 +706,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -716,16 +721,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -733,9 +738,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -744,13 +749,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -760,10 +765,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -771,8 +776,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -803,13 +809,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -817,32 +823,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -856,18 +862,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -878,15 +884,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -895,8 +901,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -912,9 +919,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/__init__.v b/CoqOfPython/ethereum/constantinople/vm/instructions/__init__.v index b8c6731..1debf2b 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/constantinople/vm/instructions/arithmetic.v index 3e3a445..e315e63 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/bitwise.v b/CoqOfPython/ethereum/constantinople/vm/instructions/bitwise.v index 76a9113..c0984ab 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/block.v b/CoqOfPython/ethereum/constantinople/vm/instructions/block.v index 5481330..ddc60b7 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/block.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.block". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/comparison.v b/CoqOfPython/ethereum/constantinople/vm/instructions/comparison.v index 50cbb7f..f4c2799 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/control_flow.v b/CoqOfPython/ethereum/constantinople/vm/instructions/control_flow.v index 4b37436..4363bee 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/environment.v b/CoqOfPython/ethereum/constantinople/vm/instructions/environment.v index e6edba3..6d28976 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -146,42 +150,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -194,21 +199,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -217,14 +222,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -236,21 +242,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -259,14 +265,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -278,31 +285,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -316,30 +324,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -350,13 +358,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -365,14 +373,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -384,24 +393,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -413,14 +422,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -436,9 +446,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -446,9 +456,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -456,9 +466,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -467,12 +477,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -485,76 +495,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -566,24 +577,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -595,14 +606,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -618,9 +630,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -628,9 +640,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -638,9 +650,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -649,12 +661,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -667,76 +679,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -748,21 +761,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -771,14 +784,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -791,12 +805,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -805,26 +819,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -836,23 +850,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -865,12 +880,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -881,9 +896,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -891,9 +906,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -901,9 +916,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -912,12 +927,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -930,52 +945,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -983,34 +998,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1021,24 +1037,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1050,14 +1066,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1069,9 +1086,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1079,9 +1096,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1089,9 +1106,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1100,12 +1117,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1118,108 +1135,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1230,12 +1248,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1244,20 +1262,20 @@ Definition extcodehash : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_CODE_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_CODE_HASH" |) ], make_dict [] |) in let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1266,15 +1284,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1287,12 +1305,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1303,16 +1321,16 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/keccak.v b/CoqOfPython/ethereum/constantinople/vm/instructions/keccak.v index 8e00e8f..c5502bf 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/log.v b/CoqOfPython/ethereum/constantinople/vm/instructions/log.v index 51269e5..b0555a1 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/log.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.log". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_constantinople_vm_stack_imports_pop : IsImported globals "ethereum.constantinople.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/memory.v b/CoqOfPython/ethereum/constantinople/vm/instructions/memory.v index 9b9ada6..627e26f 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/stack.v b/CoqOfPython/ethereum/constantinople/vm/instructions/stack.v index a87c0aa..a6d509e 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_constantinople_vm_memory_imports_buffer_read : IsImported globals "ethereum.constantinople.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/storage.v b/CoqOfPython/ethereum/constantinople/vm/instructions/storage.v index 95bb7fb..3a891f8 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -48,8 +50,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -64,9 +67,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -75,43 +78,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -125,9 +129,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -138,9 +142,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -148,11 +152,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -162,12 +166,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -176,14 +180,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -192,12 +196,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -206,8 +210,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -215,34 +219,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/instructions/system.v b/CoqOfPython/ethereum/constantinople/vm/instructions/system.v index d27c09f..6e22c0a 100644 --- a/CoqOfPython/ethereum/constantinople/vm/instructions/system.v +++ b/CoqOfPython/ethereum/constantinople/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.instructions.system". +Definition globals : Globals.t := "ethereum.constantinople.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,8 +107,9 @@ Axiom ethereum_constantinople_vm_stack_imports_push : IsImported globals "ethereum.constantinople.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in @@ -114,12 +117,12 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -129,32 +132,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -164,15 +167,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -188,10 +191,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -201,15 +204,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -230,29 +233,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -272,27 +275,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -300,10 +303,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -311,27 +314,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -344,25 +347,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -374,8 +377,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -387,9 +391,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,9 +401,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -407,9 +411,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -417,46 +421,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -465,26 +469,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -499,9 +504,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -509,9 +514,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -519,9 +524,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -530,9 +535,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -543,11 +548,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -557,12 +562,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -573,43 +578,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -618,26 +623,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -649,9 +655,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -659,9 +665,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -669,63 +675,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -733,24 +740,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -770,11 +777,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -782,10 +789,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -793,7 +800,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -801,10 +808,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -812,27 +819,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -845,23 +852,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -875,16 +882,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -896,14 +903,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -912,8 +919,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -925,12 +933,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -941,12 +949,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -957,9 +965,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,9 +975,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -977,9 +985,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -987,9 +995,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -997,9 +1005,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1007,12 +1015,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1024,15 +1032,15 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), ltac:(M.monadic ( M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) @@ -1041,7 +1049,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1049,7 +1057,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1057,13 +1065,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1071,56 +1079,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1129,25 +1137,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1156,17 +1164,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1176,32 +1184,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1209,14 +1217,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1228,12 +1237,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1244,12 +1253,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1260,9 +1269,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1270,9 +1279,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,9 +1289,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1290,9 +1299,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1300,26 +1309,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1330,13 +1339,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1344,58 +1353,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1404,17 +1413,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1424,32 +1433,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1457,14 +1466,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1476,12 +1486,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1491,27 +1501,27 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1524,7 +1534,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1533,33 +1543,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1571,15 +1581,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1587,28 +1597,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1616,33 +1626,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1652,9 +1662,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1662,19 +1672,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1684,15 +1694,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1704,12 +1715,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1720,12 +1731,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1736,9 +1747,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1746,9 +1757,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1756,9 +1767,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1766,9 +1777,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,12 +1787,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1790,76 +1801,77 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1871,12 +1883,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1887,12 +1899,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1903,9 +1915,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1913,9 +1925,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1923,9 +1935,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1933,9 +1945,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1943,12 +1955,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1957,82 +1969,83 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2044,9 +2057,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2054,9 +2067,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2064,54 +2077,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/interpreter.v b/CoqOfPython/ethereum/constantinople/vm/interpreter.v index b589da7..61036bd 100644 --- a/CoqOfPython/ethereum/constantinople/vm/interpreter.v +++ b/CoqOfPython/ethereum/constantinople/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.interpreter". +Definition globals : Globals.t := "ethereum.constantinople.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -122,7 +124,7 @@ Axiom ethereum_constantinople_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -145,8 +147,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -168,9 +171,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -182,10 +185,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -193,44 +196,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -244,10 +247,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -260,10 +263,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -272,13 +275,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -288,12 +291,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -310,14 +313,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -325,7 +328,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -333,7 +336,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -345,48 +348,48 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -394,8 +397,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -412,35 +416,35 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -448,24 +452,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -473,22 +477,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -508,13 +513,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -526,17 +531,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -544,10 +549,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -555,12 +560,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -572,10 +577,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -583,13 +588,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -597,22 +602,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -630,14 +636,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -645,13 +651,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/memory.v b/CoqOfPython/ethereum/constantinople/vm/memory.v index f8c1898..0c92e48 100644 --- a/CoqOfPython/ethereum/constantinople/vm/memory.v +++ b/CoqOfPython/ethereum/constantinople/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.memory". +Definition globals : Globals.t := "ethereum.constantinople.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/__init__.v index 028d559..3506d9b 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/alt_bn128.v index 35d5ffd..38dc21f 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_constantinople_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.constantinople.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 500 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 40000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 80000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ecrecover.v index 3738033..2f6ff0d 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_constantinople_vm_memory_imports_buffer_read : IsImported globals "ethereum.constantinople.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/identity.v index f7e428a..7f3e322 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_constantinople_vm_gas_imports_charge_gas : IsImported globals "ethereum.constantinople.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/mapping.v index 90f0895..9fa87c5 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/modexp.v index 8bbf71b..1b10eee 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,7 +37,7 @@ Axiom ethereum_constantinople_vm_memory_imports_buffer_read : Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -44,34 +46,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -87,21 +90,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -117,21 +120,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -148,36 +151,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -192,7 +195,7 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "exp_length" |), + M.get_name (| globals, locals_stack, "exp_length" |), Constant.int 32 |), (* then *) @@ -200,15 +203,15 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -227,16 +230,16 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |), @@ -244,12 +247,12 @@ Definition modexp : Value.t -> Value.t -> M := |) |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -266,22 +269,22 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.floor_div (| BinOp.mult (| M.call (| - M.get_name (| globals, "get_mult_complexity" |), + M.get_name (| globals, locals_stack, "get_mult_complexity" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -292,11 +295,11 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "adjusted_exp_length" |); + M.get_name (| globals, locals_stack, "adjusted_exp_length" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -306,7 +309,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |) |), - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) ], make_dict [] @@ -316,12 +319,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -329,9 +332,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -347,20 +350,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -371,14 +374,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -389,21 +392,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -415,39 +418,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -455,7 +458,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -466,8 +469,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_mult_complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing Karatsuba multiplication. " in @@ -475,14 +479,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 64 |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |) |) in @@ -493,7 +497,7 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 1024 |), (* then *) @@ -503,14 +507,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 4 |), BinOp.mult (| Constant.int 96, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 3072 @@ -524,14 +528,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 16 |), BinOp.mult (| Constant.int 480, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 199680 diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ripemd160.v index 9077c68..afa96a2 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_constantinople_vm_gas_imports_charge_gas : IsImported globals "ethereum.constantinople.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/sha256.v index 5e11ce8..d5c505c 100644 --- a/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/constantinople/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.constantinople.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_constantinople_vm_gas_imports_charge_gas : IsImported globals "ethereum.constantinople.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/constantinople/vm/runtime.v b/CoqOfPython/ethereum/constantinople/vm/runtime.v index f830abe..4afd430 100644 --- a/CoqOfPython/ethereum/constantinople/vm/runtime.v +++ b/CoqOfPython/ethereum/constantinople/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.runtime". +Definition globals : Globals.t := "ethereum.constantinople.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_constantinople_vm_instructions_imports_Ops : IsImported globals "ethereum.constantinople.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/constantinople/vm/stack.v b/CoqOfPython/ethereum/constantinople/vm/stack.v index afbe789..efd76ba 100644 --- a/CoqOfPython/ethereum/constantinople/vm/stack.v +++ b/CoqOfPython/ethereum/constantinople/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.constantinople.vm.stack". +Definition globals : Globals.t := "ethereum.constantinople.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_constantinople_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.constantinople.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/crypto/__init__.v b/CoqOfPython/ethereum/crypto/__init__.v index d20cfb4..5d03d2a 100644 --- a/CoqOfPython/ethereum/crypto/__init__.v +++ b/CoqOfPython/ethereum/crypto/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.crypto.__init__". +Definition globals : Globals.t := "ethereum.crypto.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/crypto/alt_bn128.v b/CoqOfPython/ethereum/crypto/alt_bn128.v index bc2b4ac..beec945 100644 --- a/CoqOfPython/ethereum/crypto/alt_bn128.v +++ b/CoqOfPython/ethereum/crypto/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.crypto.alt_bn128". +Definition globals : Globals.t := "ethereum.crypto.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -93,8 +95,9 @@ Definition BNF12 : Value.t := [ ( "__mul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiplication special cased for BNF12. " in @@ -109,9 +112,9 @@ Definition BNF12 : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 12 ], @@ -120,9 +123,9 @@ Definition BNF12 : Value.t := ltac:(M.monadic ( let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 12 ], @@ -132,20 +135,20 @@ Definition BNF12 : Value.t := let _ := M.assign_op (| BinOp.add, M.get_subscript (| - M.get_name (| globals, "mul" |), + M.get_name (| globals, locals_stack, "mul" |), BinOp.add (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "right" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_name (| globals, locals_stack, "j" |) |) |) |) in @@ -163,9 +166,9 @@ Definition BNF12 : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 22; Constant.int 11; @@ -177,16 +180,16 @@ Definition BNF12 : Value.t := let _ := M.assign_op (| BinOp.sub, M.get_subscript (| - M.get_name (| globals, "mul" |), + M.get_name (| globals, locals_stack, "mul" |), BinOp.sub (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 6 |) |), BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "mul" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "mul" |), + M.get_name (| globals, locals_stack, "i" |) |), UnOp.sub (| Constant.int 18 |) |) @@ -194,16 +197,16 @@ Definition BNF12 : Value.t := let _ := M.assign_op (| BinOp.sub, M.get_subscript (| - M.get_name (| globals, "mul" |), + M.get_name (| globals, locals_stack, "mul" |), BinOp.sub (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 12 |) |), BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "mul" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "mul" |), + M.get_name (| globals, locals_stack, "i" |) |), Constant.int 82 |) @@ -216,11 +219,11 @@ Definition BNF12 : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "__new__" |), make_list [ - M.get_name (| globals, "BNF12" |); + M.get_name (| globals, locals_stack, "BNF12" |); M.slice (| - M.get_name (| globals, "mul" |), + M.get_name (| globals, locals_stack, "mul" |), Constant.None_, Constant.int 12, Constant.None_ @@ -259,18 +262,19 @@ Definition BNP12 : Value.t := ]. Definition bnf2_to_bnf12 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x" ] in + ltac:(M.monadic ( let _ := Constant.str " Lift a field element in `BNF2` to `BNF12`. " in let _ := M.return_ (| BinOp.add (| M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -278,19 +282,19 @@ Definition bnf2_to_bnf12 : Value.t -> Value.t -> M := |), BinOp.mult (| M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 1 |) ], make_dict [] |), BinOp.sub (| - M.get_field (| M.get_name (| globals, "BNF12" |), "i_plus_9" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "i_plus_9" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 9 ], @@ -303,22 +307,23 @@ Definition bnf2_to_bnf12 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bnp_to_bnp12 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "p" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "p" ] in + ltac:(M.monadic ( let _ := Constant.str " Lift a point from `BNP` to `BNP12`. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BNP12" |), + M.get_name (| globals, locals_stack, "BNP12" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_field (| M.get_name (| globals, "p" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |) ], make_dict [] |) @@ -326,12 +331,12 @@ Definition bnp_to_bnp12 : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_field (| M.get_name (| globals, "p" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |) ], make_dict [] |) @@ -345,38 +350,39 @@ Definition bnp_to_bnp12 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition twist : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "p" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "p" ] in + ltac:(M.monadic ( let _ := Constant.str " Apply to twist to change variables from the curve `BNP2` to `BNP12`. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BNP12" |), + M.get_name (| globals, locals_stack, "BNP12" |), make_list [ BinOp.mult (| M.call (| - M.get_name (| globals, "bnf2_to_bnf12" |), + M.get_name (| globals, locals_stack, "bnf2_to_bnf12" |), make_list [ - M.get_field (| M.get_name (| globals, "p" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |) ], make_dict [] |), BinOp.pow (| - M.get_field (| M.get_name (| globals, "BNF12" |), "w" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "w" |), Constant.int 2 |) |); BinOp.mult (| M.call (| - M.get_name (| globals, "bnf2_to_bnf12" |), + M.get_name (| globals, locals_stack, "bnf2_to_bnf12" |), make_list [ - M.get_field (| M.get_name (| globals, "p" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |) ], make_dict [] |), BinOp.pow (| - M.get_field (| M.get_name (| globals, "BNF12" |), "w" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "w" |), Constant.int 3 |) |) @@ -387,8 +393,9 @@ Definition twist : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition linefunc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "p1"; "p2"; "t" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "p1"; "p2"; "t" ] in + ltac:(M.monadic ( let _ := Constant.str " Evaluate the function defining the line between points `p1` and `p2` at the point `t`. The mathematical significance of this function is that is has @@ -402,8 +409,8 @@ Definition linefunc : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "p1" |), "x" |), - M.get_field (| M.get_name (| globals, "p2" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "p2" |), "x" |) |), (* then *) ltac:(M.monadic ( @@ -411,27 +418,27 @@ Definition linefunc : Value.t -> Value.t -> M := "lam" , BinOp.div (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "p2" |), "y" |), - M.get_field (| M.get_name (| globals, "p1" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "p2" |), "y" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "y" |) |), BinOp.sub (| - M.get_field (| M.get_name (| globals, "p2" |), "x" |), - M.get_field (| M.get_name (| globals, "p1" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "p2" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "x" |) |) |) |) in let _ := M.return_ (| BinOp.sub (| BinOp.mult (| - M.get_name (| globals, "lam" |), + M.get_name (| globals, locals_stack, "lam" |), BinOp.sub (| - M.get_field (| M.get_name (| globals, "t" |), "x" |), - M.get_field (| M.get_name (| globals, "p1" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "t" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "x" |) |) |), BinOp.sub (| - M.get_field (| M.get_name (| globals, "t" |), "y" |), - M.get_field (| M.get_name (| globals, "p1" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "t" |), "y" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "y" |) |) |) |) in @@ -442,8 +449,8 @@ Definition linefunc : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "p1" |), "y" |), - M.get_field (| M.get_name (| globals, "p2" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "y" |), + M.get_field (| M.get_name (| globals, locals_stack, "p2" |), "y" |) |), (* then *) ltac:(M.monadic ( @@ -452,41 +459,41 @@ Definition linefunc : Value.t -> Value.t -> M := BinOp.div (| BinOp.mult (| M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 3 ], make_dict [] |), BinOp.pow (| - M.get_field (| M.get_name (| globals, "p1" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "x" |), Constant.int 2 |) |), BinOp.mult (| M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 2 ], make_dict [] |), - M.get_field (| M.get_name (| globals, "p1" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "y" |) |) |) |) in let _ := M.return_ (| BinOp.sub (| BinOp.mult (| - M.get_name (| globals, "lam" |), + M.get_name (| globals, locals_stack, "lam" |), BinOp.sub (| - M.get_field (| M.get_name (| globals, "t" |), "x" |), - M.get_field (| M.get_name (| globals, "p1" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "t" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "x" |) |) |), BinOp.sub (| - M.get_field (| M.get_name (| globals, "t" |), "y" |), - M.get_field (| M.get_name (| globals, "p1" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "t" |), "y" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "y" |) |) |) |) in @@ -495,8 +502,8 @@ Definition linefunc : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "t" |), "x" |), - M.get_field (| M.get_name (| globals, "p1" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "t" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "p1" |), "x" |) |) |) in M.pure Constant.None_ @@ -506,8 +513,9 @@ Definition linefunc : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition miller_loop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "q"; "p" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "q"; "p" ] in + ltac:(M.monadic ( let _ := Constant.str " The core of the pairing algorithm. " in @@ -516,18 +524,18 @@ Definition miller_loop : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP12" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP12" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP12" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP12" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -538,7 +546,7 @@ Definition miller_loop : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -552,12 +560,12 @@ Definition miller_loop : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "r" , - M.get_name (| globals, "q" |) + M.get_name (| globals, locals_stack, "q" |) |) in let _ := M.assign_local (| "f" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -566,11 +574,11 @@ Definition miller_loop : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "ATE_PAIRING_COUNT_BITS" |); + M.get_name (| globals, locals_stack, "ATE_PAIRING_COUNT_BITS" |); UnOp.sub (| Constant.int 1 |); UnOp.sub (| Constant.int 1 |) ], @@ -581,15 +589,15 @@ Definition miller_loop : Value.t -> Value.t -> M := "f" , BinOp.mult (| BinOp.mult (| - M.get_name (| globals, "f" |), - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |), + M.get_name (| globals, locals_stack, "f" |) |), M.call (| - M.get_name (| globals, "linefunc" |), + M.get_name (| globals, locals_stack, "linefunc" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "r" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -598,7 +606,7 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "r" |), "double" |), + M.get_field (| M.get_name (| globals, locals_stack, "r" |), "double" |), make_list [], make_dict [] |) @@ -608,12 +616,12 @@ Definition miller_loop : Value.t -> Value.t -> M := M.if_then_else (| BinOp.bit_and (| BinOp.sub (| - M.get_name (| globals, "ATE_PAIRING_COUNT" |), + M.get_name (| globals, locals_stack, "ATE_PAIRING_COUNT" |), Constant.int 1 |), BinOp.pow (| Constant.int 2, - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) |), (* then *) @@ -621,13 +629,13 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "f" , BinOp.mult (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), M.call (| - M.get_name (| globals, "linefunc" |), + M.get_name (| globals, locals_stack, "linefunc" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -636,8 +644,8 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , BinOp.add (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "q" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "q" |) |) |) in M.pure Constant.None_ @@ -652,12 +660,12 @@ Definition miller_loop : Value.t -> Value.t -> M := )) |) in let _ := M.assert (| Compare.eq (| - M.get_name (| globals, "r" |), + M.get_name (| globals, locals_stack, "r" |), M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ BinOp.sub (| - M.get_name (| globals, "ATE_PAIRING_COUNT" |), + M.get_name (| globals, locals_stack, "ATE_PAIRING_COUNT" |), Constant.int 1 |) ], @@ -667,15 +675,15 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "q1" , M.call (| - M.get_name (| globals, "BNP12" |), + M.get_name (| globals, locals_stack, "BNP12" |), make_list [ M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "q" |), "x" |), "frobenius" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "q" |), "x" |), "frobenius" |), make_list [], make_dict [] |); M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "q" |), "y" |), "frobenius" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "q" |), "y" |), "frobenius" |), make_list [], make_dict [] |) @@ -686,15 +694,15 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "nq2" , M.call (| - M.get_name (| globals, "BNP12" |), + M.get_name (| globals, locals_stack, "BNP12" |), make_list [ M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "q1" |), "x" |), "frobenius" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "q1" |), "x" |), "frobenius" |), make_list [], make_dict [] |); UnOp.sub (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "q1" |), "y" |), "frobenius" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "q1" |), "y" |), "frobenius" |), make_list [], make_dict [] |) |) @@ -705,13 +713,13 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "f" , BinOp.mult (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), M.call (| - M.get_name (| globals, "linefunc" |), + M.get_name (| globals, locals_stack, "linefunc" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "q1" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "q1" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -720,20 +728,20 @@ Definition miller_loop : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , BinOp.add (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "q1" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "q1" |) |) |) in let _ := M.assign_local (| "f" , BinOp.mult (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), M.call (| - M.get_name (| globals, "linefunc" |), + M.get_name (| globals, locals_stack, "linefunc" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "nq2" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "nq2" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -741,42 +749,43 @@ Definition miller_loop : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), BinOp.floor_div (| BinOp.sub (| BinOp.pow (| - M.get_name (| globals, "ALT_BN128_PRIME" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |), Constant.int 12 |), Constant.int 1 |), - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) |) |) |) in M.pure Constant.None_)). Definition pairing : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "q"; "p" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "q"; "p" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the pairing of `q` and `p`. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "miller_loop" |), + M.get_name (| globals, locals_stack, "miller_loop" |), make_list [ M.call (| - M.get_name (| globals, "twist" |), + M.get_name (| globals, locals_stack, "twist" |), make_list [ - M.get_name (| globals, "q" |) + M.get_name (| globals, locals_stack, "q" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "bnp_to_bnp12" |), + M.get_name (| globals, locals_stack, "bnp_to_bnp12" |), make_list [ - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/crypto/blake2.v b/CoqOfPython/ethereum/crypto/blake2.v index 6cd27f7..6363258 100644 --- a/CoqOfPython/ethereum/crypto/blake2.v +++ b/CoqOfPython/ethereum/crypto/blake2.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.crypto.blake2". +Definition globals : Globals.t := "ethereum.crypto.blake2". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -22,8 +24,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition spit_le_to_uint : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data"; "start"; "num_words" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data"; "start"; "num_words" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts 8 byte words from a given data. @@ -42,11 +45,11 @@ Definition spit_le_to_uint : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_words" |) + M.get_name (| globals, locals_stack, "num_words" |) ], make_dict [] |), @@ -54,24 +57,24 @@ Definition spit_le_to_uint : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , BinOp.add (| - M.get_name (| globals, "start" |), + M.get_name (| globals, locals_stack, "start" |), BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 8 |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "words" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "words" |), "append" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_le_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_le_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "data" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "start_position" |), Constant.int 8 |), Constant.None_ @@ -89,7 +92,7 @@ Definition spit_le_to_uint : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "words" |) |) in M.pure Constant.None_)). @@ -102,8 +105,9 @@ Definition Blake2 : Value.t := [ ( "get_blake2_parameters", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Extract the parameters required in the Blake2 compression function from the provided bytes data. @@ -116,10 +120,10 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "rounds" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.None_, Constant.int 4, Constant.None_ @@ -131,9 +135,9 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "h" , M.call (| - M.get_name (| globals, "spit_le_to_uint" |), + M.get_name (| globals, locals_stack, "spit_le_to_uint" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); Constant.int 4; Constant.int 8 ], @@ -143,9 +147,9 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "m" , M.call (| - M.get_name (| globals, "spit_le_to_uint" |), + M.get_name (| globals, locals_stack, "spit_le_to_uint" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); Constant.int 68; Constant.int 16 ], @@ -153,11 +157,11 @@ Definition Blake2 : Value.t := |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |) ], M.call (| - M.get_name (| globals, "spit_le_to_uint" |), + M.get_name (| globals, locals_stack, "spit_le_to_uint" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); Constant.int 196; Constant.int 2 ], @@ -167,10 +171,10 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "f" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), Constant.int 212, Constant.None_, Constant.None_ @@ -180,14 +184,15 @@ Definition Blake2 : Value.t := |) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ] |) in M.pure Constant.None_)) ); ( "G", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "v"; "a"; "b"; "c"; "d"; "x"; "y" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "v"; "a"; "b"; "c"; "d"; "x"; "y" ] in + ltac:(M.monadic ( let _ := Constant.str " The mixing function used in Blake2 https://datatracker.ietf.org/doc/html/rfc7693#section-3.1 @@ -203,243 +208,244 @@ Definition Blake2 : Value.t := " in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |), BinOp.mod_ (| BinOp.add (| BinOp.add (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |) |), - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |), BinOp.bit_xor (| BinOp.r_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "R1" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "R1" |) |), BinOp.mod_ (| BinOp.l_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "w_R1" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "w_R1" |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |), BinOp.mod_ (| BinOp.add (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |), BinOp.bit_xor (| BinOp.r_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "R2" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "R2" |) |), BinOp.mod_ (| BinOp.l_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "w_R2" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "w_R2" |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |), BinOp.mod_ (| BinOp.add (| BinOp.add (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |) |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |), BinOp.bit_xor (| BinOp.r_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "R3" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "R3" |) |), BinOp.mod_ (| BinOp.l_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "a" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "w_R3" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "w_R3" |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |), BinOp.mod_ (| BinOp.add (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "d" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "d" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |), BinOp.bit_xor (| BinOp.r_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "R4" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "R4" |) |), BinOp.mod_ (| BinOp.l_shift (| BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "b" |) |), M.get_subscript (| - M.get_name (| globals, "v" |), - M.get_name (| globals, "c" |) + M.get_name (| globals, locals_stack, "v" |), + M.get_name (| globals, locals_stack, "c" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "w_R4" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "w_R4" |) |), - M.get_field (| M.get_name (| globals, "self" |), "max_word" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "max_word" |) |) |) |) in let _ := M.return_ (| - M.get_name (| globals, "v" |) + M.get_name (| globals, locals_stack, "v" |) |) in M.pure Constant.None_)) ); ( "compress", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "num_rounds"; "h"; "m"; "t_0"; "t_1"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "num_rounds"; "h"; "m"; "t_0"; "t_1"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " 'F Compression' from section 3.2 of RFC 7693: https://tools.ietf.org/html/rfc7693#section-3.2 @@ -468,44 +474,44 @@ Definition Blake2 : Value.t := |) in let _ := M.assign (| M.slice (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 0, Constant.int 8, Constant.None_ |), - M.get_name (| globals, "h" |) + M.get_name (| globals, locals_stack, "h" |) |) in let _ := M.assign (| M.slice (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 8, Constant.int 15, Constant.None_ |), - M.get_field (| M.get_name (| globals, "self" |), "IV" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "IV" |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 12 |), BinOp.bit_xor (| - M.get_name (| globals, "t_0" |), + M.get_name (| globals, locals_stack, "t_0" |), M.get_subscript (| - M.get_field (| M.get_name (| globals, "self" |), "IV" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "IV" |), Constant.int 4 |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 13 |), BinOp.bit_xor (| - M.get_name (| globals, "t_1" |), + M.get_name (| globals, locals_stack, "t_1" |), M.get_subscript (| - M.get_field (| M.get_name (| globals, "self" |), "IV" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "IV" |), Constant.int 5 |) |) @@ -513,20 +519,20 @@ Definition Blake2 : Value.t := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), (* then *) ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 14 |), BinOp.bit_xor (| M.get_subscript (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 14 |), - M.get_field (| M.get_name (| globals, "self" |), "mask_bits" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "mask_bits" |) |) |) in M.pure Constant.None_ @@ -536,11 +542,11 @@ Definition Blake2 : Value.t := )) |) in let _ := M.for_ (| - M.get_name (| globals, "r" |), + M.get_name (| globals, locals_stack, "r" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_rounds" |) + M.get_name (| globals, locals_stack, "num_rounds" |) ], make_dict [] |), @@ -548,34 +554,34 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "s" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "self" |), "sigma" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "sigma" |), BinOp.mod_ (| - M.get_name (| globals, "r" |), - M.get_field (| M.get_name (| globals, "self" |), "sigma_len" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "sigma_len" |) |) |) |) in let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 0; Constant.int 4; Constant.int 8; Constant.int 12; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 0 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 1 |) |) @@ -586,24 +592,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 1; Constant.int 5; Constant.int 9; Constant.int 13; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 2 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 3 |) |) @@ -614,24 +620,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 2; Constant.int 6; Constant.int 10; Constant.int 14; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 4 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 5 |) |) @@ -642,24 +648,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 3; Constant.int 7; Constant.int 11; Constant.int 15; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 6 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 7 |) |) @@ -670,24 +676,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 0; Constant.int 5; Constant.int 10; Constant.int 15; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 8 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 9 |) |) @@ -698,24 +704,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 1; Constant.int 6; Constant.int 11; Constant.int 12; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 10 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 11 |) |) @@ -726,24 +732,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 2; Constant.int 7; Constant.int 8; Constant.int 13; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 12 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 13 |) |) @@ -754,24 +760,24 @@ Definition Blake2 : Value.t := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "G" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "G" |), make_list [ - M.get_name (| globals, "v" |); + M.get_name (| globals, locals_stack, "v" |); Constant.int 3; Constant.int 4; Constant.int 9; Constant.int 14; M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 14 |) |); M.get_subscript (| - M.get_name (| globals, "m" |), + M.get_name (| globals, locals_stack, "m" |), M.get_subscript (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), Constant.int 15 |) |) @@ -791,15 +797,15 @@ Definition Blake2 : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "struct" |), "pack" |), + M.get_field (| M.get_name (| globals, locals_stack, "struct" |), "pack" |), make_list_concat (| [ make_list [ BinOp.mod_ (| Constant.str "<8%s", - M.get_field (| M.get_name (| globals, "self" |), "word_format" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "word_format" |) |) ]; - M.get_name (| globals, "result_message_words" |) + M.get_name (| globals, locals_stack, "result_message_words" |) ] |), make_dict [] |) diff --git a/CoqOfPython/ethereum/crypto/elliptic_curve.v b/CoqOfPython/ethereum/crypto/elliptic_curve.v index 3b7436b..c8adbad 100644 --- a/CoqOfPython/ethereum/crypto/elliptic_curve.v +++ b/CoqOfPython/ethereum/crypto/elliptic_curve.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.crypto.elliptic_curve". +Definition globals : Globals.t := "ethereum.crypto.elliptic_curve". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,7 +36,7 @@ Definition SECP256K1N : Value.t := M.run ltac:(M.monadic ( Definition F : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "F" ], @@ -44,7 +46,7 @@ Definition F : Value.t := M.run ltac:(M.monadic ( Definition T : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "T" ], @@ -53,8 +55,9 @@ Definition T : Value.t := M.run ltac:(M.monadic ( )). Definition secp256k1_recover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "r"; "s"; "v"; "msg_hash" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "r"; "s"; "v"; "msg_hash" ] in + ltac:(M.monadic ( let _ := Constant.str " Recovers the public key from a given signature. @@ -77,7 +80,7 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r_bytes" , M.call (| - M.get_field (| M.get_name (| globals, "r" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "r" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -85,7 +88,7 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s_bytes" , M.call (| - M.get_field (| M.get_name (| globals, "s" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "s" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -93,7 +96,7 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := let _ := M.assign_local (| "signature" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ @@ -107,13 +110,13 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.slice (| - M.get_name (| globals, "signature" |), + M.get_name (| globals, locals_stack, "signature" |), BinOp.sub (| Constant.int 32, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "r_bytes" |) + M.get_name (| globals, locals_stack, "r_bytes" |) ], make_dict [] |) @@ -121,17 +124,17 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := Constant.int 32, Constant.None_ |), - M.get_name (| globals, "r_bytes" |) + M.get_name (| globals, locals_stack, "r_bytes" |) |) in let _ := M.assign (| M.slice (| - M.get_name (| globals, "signature" |), + M.get_name (| globals, locals_stack, "signature" |), BinOp.sub (| Constant.int 64, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "s_bytes" |) + M.get_name (| globals, locals_stack, "s_bytes" |) ], make_dict [] |) @@ -139,28 +142,28 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := Constant.int 64, Constant.None_ |), - M.get_name (| globals, "s_bytes" |) + M.get_name (| globals, locals_stack, "s_bytes" |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "signature" |), + M.get_name (| globals, locals_stack, "signature" |), Constant.int 64 |), - M.get_name (| globals, "v" |) + M.get_name (| globals, locals_stack, "v" |) |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "coincurve" |), "PublicKey" |), "from_signature_and_message" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "coincurve" |), "PublicKey" |), "from_signature_and_message" |), make_list [ M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "signature" |) + M.get_name (| globals, locals_stack, "signature" |) ], make_dict [] |); - M.get_name (| globals, "msg_hash" |) + M.get_name (| globals, locals_stack, "msg_hash" |) ], make_dict [] |) @@ -169,7 +172,7 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := "public_key" , M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "public_key" |), "format" |), + M.get_field (| M.get_name (| globals, locals_stack, "public_key" |), "format" |), make_list [], make_dict [] |), @@ -179,7 +182,7 @@ Definition secp256k1_recover : Value.t -> Value.t -> M := |) |) in let _ := M.return_ (| - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) |) in M.pure Constant.None_)). @@ -189,8 +192,9 @@ Definition EllipticCurve : Value.t := [ ( "point_at_infinity", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := Constant.str " Return the point at infinity. This is the identity element of the group operation. @@ -200,16 +204,16 @@ Definition EllipticCurve : Value.t := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "cls" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "cls" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "FIELD" |), "zero" |), make_list [], make_dict [] |); M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "cls" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "FIELD" |), "zero" |), make_list [], make_dict [] |) @@ -223,8 +227,9 @@ Definition EllipticCurve : Value.t := [ ( "__new__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "x"; "y" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "x"; "y" ] in + ltac:(M.monadic ( let _ := Constant.str " Make new point on the curve. The point is not checked to see if it is on the curve. @@ -232,30 +237,31 @@ Definition EllipticCurve : Value.t := let _ := M.assign_local (| "res" , M.call (| - M.get_field (| M.get_name (| globals, "object" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "object" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "res" |), "x" |), - M.get_name (| globals, "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "res" |), "x" |), + M.get_name (| globals, locals_stack, "x" |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "res" |), "y" |), - M.get_name (| globals, "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "res" |), "y" |), + M.get_name (| globals, locals_stack, "y" |) |) in let _ := M.return_ (| - M.get_name (| globals, "res" |) + M.get_name (| globals, locals_stack, "res" |) |) in M.pure Constant.None_)) ); ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "x"; "y" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "x"; "y" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the point is on the curve. To skip this check call `__new__()` directly. @@ -266,18 +272,18 @@ Definition EllipticCurve : Value.t := BoolOp.and (| BoolOp.or (| Compare.not_eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "self" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |), "zero" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "self" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |), "zero" |), make_list [], make_dict [] |) @@ -290,23 +296,23 @@ Definition EllipticCurve : Value.t := BinOp.sub (| BinOp.sub (| BinOp.pow (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 2 |), BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 3 |) |), BinOp.mult (| - M.get_field (| M.get_name (| globals, "self" |), "A" |), - M.get_name (| globals, "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "A" |), + M.get_name (| globals, locals_stack, "x" |) |) |), - M.get_field (| M.get_name (| globals, "self" |), "B" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "B" |) |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "self" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |), "zero" |), make_list [], make_dict [] |) @@ -316,7 +322,7 @@ Definition EllipticCurve : Value.t := (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [ Constant.str "Point not on curve" ], @@ -331,8 +337,9 @@ Definition EllipticCurve : Value.t := ); ( "__eq__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "other" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "other" ] in + ltac:(M.monadic ( let _ := Constant.str " Test two points for equality. " in @@ -340,13 +347,13 @@ Definition EllipticCurve : Value.t := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "other" |); + M.get_name (| globals, locals_stack, "other" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) @@ -366,13 +373,13 @@ Definition EllipticCurve : Value.t := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "self" |), "x" |), - M.get_field (| M.get_name (| globals, "other" |), "x" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "x" |), + M.get_field (| M.get_name (| globals, locals_stack, "other" |), "x" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "self" |), "y" |), - M.get_field (| M.get_name (| globals, "other" |), "y" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "y" |), + M.get_field (| M.get_name (| globals, locals_stack, "other" |), "y" |) |) )) |) @@ -381,16 +388,17 @@ Definition EllipticCurve : Value.t := ); ( "__str__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Stringify a point as its coordinates. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "str" |), + M.get_name (| globals, locals_stack, "str" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "self" |), "x" |); M.get_field (| M.get_name (| globals, "self" |), "y" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "self" |), "x" |); M.get_field (| M.get_name (| globals, locals_stack, "self" |), "y" |) ] ], make_dict [] |) @@ -399,26 +407,27 @@ Definition EllipticCurve : Value.t := ); ( "double", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a point to itself. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "x" |); M.get_name (| globals, "y" |); M.get_name (| globals, "F" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "self" |), "x" |); M.get_field (| M.get_name (| globals, "self" |), "y" |); M.get_field (| M.get_name (| globals, "self" |), "FIELD" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "x" |); M.get_name (| globals, locals_stack, "y" |); M.get_name (| globals, locals_stack, "F" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "self" |), "x" |); M.get_field (| M.get_name (| globals, locals_stack, "self" |), "y" |); M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |) ] |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |) )) @@ -426,7 +435,7 @@ Definition EllipticCurve : Value.t := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) |) in M.pure Constant.None_ (* else *) @@ -439,28 +448,28 @@ Definition EllipticCurve : Value.t := BinOp.add (| BinOp.mult (| M.call (| - M.get_field (| M.get_name (| globals, "F" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "F" |), "from_int" |), make_list [ Constant.int 3 ], make_dict [] |), BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |) |), - M.get_field (| M.get_name (| globals, "self" |), "A" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "A" |) |), BinOp.mult (| M.call (| - M.get_field (| M.get_name (| globals, "F" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "F" |), "from_int" |), make_list [ Constant.int 2 ], make_dict [] |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) |) |) |) in @@ -469,40 +478,40 @@ Definition EllipticCurve : Value.t := BinOp.sub (| BinOp.sub (| BinOp.pow (| - M.get_name (| globals, "lam" |), + M.get_name (| globals, locals_stack, "lam" |), Constant.int 2 |), - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |), - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |) in let _ := M.assign_local (| "new_y" , BinOp.sub (| BinOp.mult (| - M.get_name (| globals, "lam" |), + M.get_name (| globals, locals_stack, "lam" |), BinOp.sub (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "new_x" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "new_x" |) |) |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) |) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); - M.get_name (| globals, "new_x" |); - M.get_name (| globals, "new_y" |) + M.get_name (| globals, locals_stack, "new_x" |); + M.get_name (| globals, locals_stack, "new_y" |) ], make_dict [] |) @@ -511,42 +520,43 @@ Definition EllipticCurve : Value.t := ); ( "__add__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "other" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "other" ] in + ltac:(M.monadic ( let _ := Constant.str " Add two points together. " in let _ := M.assign_local (| "ZERO" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "self" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |), "zero" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "self_x" |); M.get_name (| globals, "self_y" |); M.get_name (| globals, "other_x" |); M.get_name (| globals, "other_y" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "self" |), "x" |); M.get_field (| M.get_name (| globals, "self" |), "y" |); M.get_field (| M.get_name (| globals, "other" |), "x" |); M.get_field (| M.get_name (| globals, "other" |), "y" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "self_x" |); M.get_name (| globals, locals_stack, "self_y" |); M.get_name (| globals, locals_stack, "other_x" |); M.get_name (| globals, locals_stack, "other_y" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "self" |), "x" |); M.get_field (| M.get_name (| globals, locals_stack, "self" |), "y" |); M.get_field (| M.get_name (| globals, locals_stack, "other" |), "x" |); M.get_field (| M.get_name (| globals, locals_stack, "other" |), "y" |) ] |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "self_x" |), - M.get_name (| globals, "ZERO" |) + M.get_name (| globals, locals_stack, "self_x" |), + M.get_name (| globals, locals_stack, "ZERO" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "self_y" |), - M.get_name (| globals, "ZERO" |) + M.get_name (| globals, locals_stack, "self_y" |), + M.get_name (| globals, locals_stack, "ZERO" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "other" |) + M.get_name (| globals, locals_stack, "other" |) |) in M.pure Constant.None_ (* else *) @@ -558,20 +568,20 @@ Definition EllipticCurve : Value.t := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "other_x" |), - M.get_name (| globals, "ZERO" |) + M.get_name (| globals, locals_stack, "other_x" |), + M.get_name (| globals, locals_stack, "ZERO" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "other_y" |), - M.get_name (| globals, "ZERO" |) + M.get_name (| globals, locals_stack, "other_y" |), + M.get_name (| globals, locals_stack, "ZERO" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) |) in M.pure Constant.None_ (* else *) @@ -582,8 +592,8 @@ Definition EllipticCurve : Value.t := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "self_x" |), - M.get_name (| globals, "other_x" |) + M.get_name (| globals, locals_stack, "self_x" |), + M.get_name (| globals, locals_stack, "other_x" |) |), (* then *) ltac:(M.monadic ( @@ -591,14 +601,14 @@ Definition EllipticCurve : Value.t := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "self_y" |), - M.get_name (| globals, "other_y" |) + M.get_name (| globals, locals_stack, "self_y" |), + M.get_name (| globals, locals_stack, "other_y" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "double" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "double" |), make_list [], make_dict [] |) @@ -608,7 +618,7 @@ Definition EllipticCurve : Value.t := )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -624,12 +634,12 @@ Definition EllipticCurve : Value.t := "lam" , BinOp.div (| BinOp.sub (| - M.get_name (| globals, "other_y" |), - M.get_name (| globals, "self_y" |) + M.get_name (| globals, locals_stack, "other_y" |), + M.get_name (| globals, locals_stack, "self_y" |) |), BinOp.sub (| - M.get_name (| globals, "other_x" |), - M.get_name (| globals, "self_x" |) + M.get_name (| globals, locals_stack, "other_x" |), + M.get_name (| globals, locals_stack, "self_x" |) |) |) |) in @@ -638,40 +648,40 @@ Definition EllipticCurve : Value.t := BinOp.sub (| BinOp.sub (| BinOp.pow (| - M.get_name (| globals, "lam" |), + M.get_name (| globals, locals_stack, "lam" |), Constant.int 2 |), - M.get_name (| globals, "self_x" |) + M.get_name (| globals, locals_stack, "self_x" |) |), - M.get_name (| globals, "other_x" |) + M.get_name (| globals, locals_stack, "other_x" |) |) |) in let _ := M.assign_local (| "y" , BinOp.sub (| BinOp.mult (| - M.get_name (| globals, "lam" |), + M.get_name (| globals, locals_stack, "lam" |), BinOp.sub (| - M.get_name (| globals, "self_x" |), - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "self_x" |), + M.get_name (| globals, locals_stack, "x" |) |) |), - M.get_name (| globals, "self_y" |) + M.get_name (| globals, locals_stack, "self_y" |) |) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); - M.get_name (| globals, "x" |); - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |); + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -680,30 +690,31 @@ Definition EllipticCurve : Value.t := ); ( "mul_by", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "n" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "n" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply `self` by `n` using the double and add algorithm. " in let _ := M.assign_local (| "res" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "self" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |), "zero" |), make_list [], make_dict [] |); M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "self" |), "FIELD" |), "zero" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FIELD" |), "zero" |), make_list [], make_dict [] |) @@ -713,12 +724,12 @@ Definition EllipticCurve : Value.t := |) in let _ := M.assign_local (| "s" , - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) |) in let _ := M.while (| Compare.not_eq (| - M.get_name (| globals, "n" |), + M.get_name (| globals, locals_stack, "n" |), Constant.int 0 |), ltac:(M.monadic ( @@ -727,7 +738,7 @@ Definition EllipticCurve : Value.t := M.if_then_else (| Compare.eq (| BinOp.mod_ (| - M.get_name (| globals, "n" |), + M.get_name (| globals, locals_stack, "n" |), Constant.int 2 |), Constant.int 1 @@ -737,8 +748,8 @@ Definition EllipticCurve : Value.t := let _ := M.assign_local (| "res" , BinOp.add (| - M.get_name (| globals, "res" |), - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "res" |), + M.get_name (| globals, locals_stack, "s" |) |) |) in M.pure Constant.None_ @@ -749,8 +760,8 @@ Definition EllipticCurve : Value.t := let _ := M.assign_local (| "s" , BinOp.add (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "s" |) |) |) in let _ := M.assign_op_local (| @@ -765,7 +776,7 @@ Definition EllipticCurve : Value.t := )) |) in let _ := M.return_ (| - M.get_name (| globals, "res" |) + M.get_name (| globals, locals_stack, "res" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/crypto/finite_field.v b/CoqOfPython/ethereum/crypto/finite_field.v index fa90840..458e285 100644 --- a/CoqOfPython/ethereum/crypto/finite_field.v +++ b/CoqOfPython/ethereum/crypto/finite_field.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.crypto.finite_field". +Definition globals : Globals.t := "ethereum.crypto.finite_field". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -31,7 +33,7 @@ Axiom ethereum_base_types_imports_Bytes32 : Definition F : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "F" ], @@ -45,15 +47,17 @@ Definition Field : Value.t := [ ( "zero", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "from_int", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "n" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "n" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ) @@ -61,85 +65,97 @@ Definition Field : Value.t := [ ( "__radd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__add__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__iadd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__sub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__rsub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__mul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__rmul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__imul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__pow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "exponent" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "exponent" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__ipow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__neg__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ); ( "__truediv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := Constant.ellipsis in M.pure Constant.None_)) ) @@ -147,7 +163,7 @@ Definition Field : Value.t := Definition T : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "T" ], @@ -161,8 +177,9 @@ Definition PrimeField : Value.t := [ ( "from_be_bytes", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a sequence of bytes into a element of the field. Parameters @@ -176,12 +193,12 @@ Definition PrimeField : Value.t := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "int" |), "from_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "from_bytes" |), make_list [ - M.get_name (| globals, "buffer" |); + M.get_name (| globals, locals_stack, "buffer" |); Constant.str "big" ], make_dict [] @@ -194,13 +211,14 @@ Definition PrimeField : Value.t := ); ( "zero", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "cls" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); Constant.int 0 ], make_dict [] @@ -210,13 +228,14 @@ Definition PrimeField : Value.t := ); ( "from_int", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "n" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "n" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) @@ -227,16 +246,17 @@ Definition PrimeField : Value.t := [ ( "__new__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "value" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); BinOp.mod_ (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "cls" |), "PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "PRIME" |) |) ], make_dict [] @@ -246,13 +266,14 @@ Definition PrimeField : Value.t := ); ( "__radd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -261,23 +282,24 @@ Definition PrimeField : Value.t := ); ( "__add__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -286,20 +308,20 @@ Definition PrimeField : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__add__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -311,13 +333,14 @@ Definition PrimeField : Value.t := ); ( "__iadd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -326,23 +349,24 @@ Definition PrimeField : Value.t := ); ( "__sub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -351,20 +375,20 @@ Definition PrimeField : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__sub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__sub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -376,23 +400,24 @@ Definition PrimeField : Value.t := ); ( "__rsub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "left" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -401,20 +426,20 @@ Definition PrimeField : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__rsub__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__rsub__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -426,23 +451,24 @@ Definition PrimeField : Value.t := ); ( "__mul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); - M.get_name (| globals, "int" |) + M.get_name (| globals, locals_stack, "right" |); + M.get_name (| globals, locals_stack, "int" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -451,20 +477,20 @@ Definition PrimeField : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__mul__" |), make_list [ - M.get_name (| globals, "self" |); - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "self" |); + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -476,13 +502,14 @@ Definition PrimeField : Value.t := ); ( "__rmul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -491,13 +518,14 @@ Definition PrimeField : Value.t := ); ( "__imul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -506,31 +534,32 @@ Definition PrimeField : Value.t := ); ( "__pow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "exponent" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "exponent" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__pow__" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); - M.get_name (| globals, "exponent" |); - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_name (| globals, locals_stack, "exponent" |); + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) ], make_dict [] |) @@ -542,13 +571,14 @@ Definition PrimeField : Value.t := ); ( "__ipow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__pow__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -557,23 +587,24 @@ Definition PrimeField : Value.t := ); ( "__neg__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "int" |), "__neg__" |), + M.get_field (| M.get_name (| globals, locals_stack, "int" |), "__neg__" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) @@ -585,13 +616,14 @@ Definition PrimeField : Value.t := ); ( "__truediv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| BinOp.mult (| - M.get_name (| globals, "self" |), + M.get_name (| globals, locals_stack, "self" |), M.call (| - M.get_field (| M.get_name (| globals, "right" |), "multiplicative_inverse" |), + M.get_field (| M.get_name (| globals, locals_stack, "right" |), "multiplicative_inverse" |), make_list [], make_dict [] |) @@ -601,11 +633,12 @@ Definition PrimeField : Value.t := ); ( "multiplicative_inverse", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "self" |), + M.get_name (| globals, locals_stack, "self" |), UnOp.sub (| Constant.int 1 |) |) |) in @@ -613,8 +646,9 @@ Definition PrimeField : Value.t := ); ( "to_be_bytes32", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts this arbitrarily sized unsigned integer into its big endian representation with exactly 32 bytes. @@ -625,10 +659,10 @@ Definition PrimeField : Value.t := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes32" |), + M.get_name (| globals, locals_stack, "Bytes32" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "self" |), "to_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "to_bytes" |), make_list [ Constant.int 32; Constant.str "big" @@ -645,7 +679,7 @@ Definition PrimeField : Value.t := Definition U : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "U" ], @@ -659,21 +693,22 @@ Definition GaloisField : Value.t := [ ( "zero", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "cls" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); BinOp.mult (| make_list [ Constant.int 0 ], M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "MODULUS" |) ], make_dict [] |) @@ -686,16 +721,17 @@ Definition GaloisField : Value.t := ); ( "from_int", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "n" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "n" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "cls" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); BinOp.add (| make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], BinOp.mult (| make_list [ @@ -703,9 +739,9 @@ Definition GaloisField : Value.t := ], BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "MODULUS" |) ], make_dict [] |), @@ -721,8 +757,9 @@ Definition GaloisField : Value.t := ); ( "calculate_frobenius_coefficients", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the coefficients needed by `frobenius()`. " in @@ -732,14 +769,14 @@ Definition GaloisField : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "MODULUS" |) ], make_dict [] |) @@ -754,9 +791,9 @@ Definition GaloisField : Value.t := Constant.int 0 ], M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "MODULUS" |) ], make_dict [] |) @@ -764,24 +801,24 @@ Definition GaloisField : Value.t := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |), Constant.int 1 |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "coefficients" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "coefficients" |), "append" |), make_list [ BinOp.pow (| M.call (| - M.get_field (| M.get_name (| globals, "cls" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "cls" |); + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "cls" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "PRIME" |) |) ], make_dict [] @@ -794,9 +831,9 @@ Definition GaloisField : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ - M.get_name (| globals, "coefficients" |) + M.get_name (| globals, locals_stack, "coefficients" |) ], make_dict [] |) @@ -807,14 +844,15 @@ Definition GaloisField : Value.t := [ ( "__new__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "iterable" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "iterable" ] in + ltac:(M.monadic ( let _ := M.assign_local (| "self" , M.call (| - M.get_field (| M.get_name (| globals, "tuple" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "tuple" |), "__new__" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); Constant.str "(* At expr: unsupported node type: GeneratorExp *)" ], make_dict [] @@ -822,40 +860,41 @@ Definition GaloisField : Value.t := |) in let _ := M.assert (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "MODULUS" |) ], make_dict [] |) |) |) in let _ := M.return_ (| - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) |) in M.pure Constant.None_)) ); ( "__add__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); + M.get_name (| globals, locals_stack, "right" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) @@ -865,7 +904,7 @@ Definition GaloisField : Value.t := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -874,12 +913,12 @@ Definition GaloisField : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); @@ -892,13 +931,14 @@ Definition GaloisField : Value.t := ); ( "__radd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -907,13 +947,14 @@ Definition GaloisField : Value.t := ); ( "__iadd__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__add__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__add__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -922,19 +963,20 @@ Definition GaloisField : Value.t := ); ( "__sub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "right" |); + M.get_name (| globals, locals_stack, "right" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) @@ -944,7 +986,7 @@ Definition GaloisField : Value.t := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -955,12 +997,12 @@ Definition GaloisField : Value.t := (* At stmt: unsupported node type: AnnAssign *) let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); @@ -973,19 +1015,20 @@ Definition GaloisField : Value.t := ); ( "__rsub__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "left" |); + M.get_name (| globals, locals_stack, "left" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) @@ -995,7 +1038,7 @@ Definition GaloisField : Value.t := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_ (* else *) @@ -1004,12 +1047,12 @@ Definition GaloisField : Value.t := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); @@ -1022,25 +1065,26 @@ Definition GaloisField : Value.t := ); ( "__mul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.assign_local (| "modulus" , - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) |) in let _ := M.assign_local (| "degree" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) |) in let _ := M.assign_local (| "prime" , - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) |) in let _ := M.assign_local (| "mul" , @@ -1049,29 +1093,29 @@ Definition GaloisField : Value.t := Constant.int 0 ], BinOp.mult (| - M.get_name (| globals, "degree" |), + M.get_name (| globals, locals_stack, "degree" |), Constant.int 2 |) |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "degree" |) + M.get_name (| globals, locals_stack, "degree" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "degree" |) + M.get_name (| globals, locals_stack, "degree" |) ], make_dict [] |), @@ -1079,20 +1123,20 @@ Definition GaloisField : Value.t := let _ := M.assign_op (| BinOp.add, M.get_subscript (| - M.get_name (| globals, "mul" |), + M.get_name (| globals, locals_stack, "mul" |), BinOp.add (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "right" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "right" |), + M.get_name (| globals, locals_stack, "j" |) |) |) |) in @@ -1110,19 +1154,19 @@ Definition GaloisField : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.sub (| BinOp.mult (| - M.get_name (| globals, "degree" |), + M.get_name (| globals, locals_stack, "degree" |), Constant.int 2 |), Constant.int 1 |); BinOp.sub (| - M.get_name (| globals, "degree" |), + M.get_name (| globals, locals_stack, "degree" |), Constant.int 1 |); UnOp.sub (| Constant.int 1 |) @@ -1132,15 +1176,15 @@ Definition GaloisField : Value.t := ltac:(M.monadic ( let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.sub (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "degree" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "degree" |) |); - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |), @@ -1148,27 +1192,27 @@ Definition GaloisField : Value.t := let _ := M.assign_op (| BinOp.sub, M.get_subscript (| - M.get_name (| globals, "mul" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "mul" |), + M.get_name (| globals, locals_stack, "j" |) |), BinOp.mod_ (| BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "mul" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "mul" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), BinOp.sub (| - M.get_name (| globals, "degree" |), + M.get_name (| globals, locals_stack, "degree" |), BinOp.sub (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "j" |) |) |) |) |), - M.get_name (| globals, "prime" |) + M.get_name (| globals, locals_stack, "prime" |) |) |) in M.pure Constant.None_ @@ -1185,19 +1229,19 @@ Definition GaloisField : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); M.slice (| - M.get_name (| globals, "mul" |), + M.get_name (| globals, locals_stack, "mul" |), Constant.None_, - M.get_name (| globals, "degree" |), + M.get_name (| globals, locals_stack, "degree" |), Constant.None_ |) ], @@ -1208,13 +1252,14 @@ Definition GaloisField : Value.t := ); ( "__rmul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "left" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "left" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "left" |) + M.get_name (| globals, locals_stack, "left" |) ], make_dict [] |) @@ -1223,13 +1268,14 @@ Definition GaloisField : Value.t := ); ( "__imul__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__mul__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__mul__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -1238,13 +1284,14 @@ Definition GaloisField : Value.t := ); ( "__truediv__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| BinOp.mult (| - M.get_name (| globals, "self" |), + M.get_name (| globals, locals_stack, "self" |), M.call (| - M.get_field (| M.get_name (| globals, "right" |), "multiplicative_inverse" |), + M.get_field (| M.get_name (| globals, locals_stack, "right" |), "multiplicative_inverse" |), make_list [], make_dict [] |) @@ -1254,16 +1301,17 @@ Definition GaloisField : Value.t := ); ( "__neg__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); @@ -1276,20 +1324,21 @@ Definition GaloisField : Value.t := ); ( "scalar_mul", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "x" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "x" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply a field element by a integer. This is faster than using `from_int()` and field multiplication. " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); @@ -1302,22 +1351,23 @@ Definition GaloisField : Value.t := ); ( "deg", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " This is a support function for `multiplicative_inverse()`. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) ], make_dict [] |), @@ -1334,15 +1384,15 @@ Definition GaloisField : Value.t := M.if_then_else (| Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "self" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "self" |), + M.get_name (| globals, locals_stack, "i" |) |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -1356,7 +1406,7 @@ Definition GaloisField : Value.t := )) |) in let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "ValueError" |), + M.get_name (| globals, locals_stack, "ValueError" |), make_list [ Constant.str "deg() does not support zero" ], @@ -1366,22 +1416,23 @@ Definition GaloisField : Value.t := ); ( "multiplicative_inverse", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the multiplicative inverse. Uses the Euclidean algorithm. " in (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "p" , - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "x1" |); M.get_name (| globals, "f1" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "x1" |); M.get_name (| globals, locals_stack, "f1" |) ], make_tuple [ M.call (| - M.get_name (| globals, "list" |), + M.get_name (| globals, locals_stack, "list" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) ], make_dict [] |); BinOp.mult (| @@ -1389,20 +1440,20 @@ Definition GaloisField : Value.t := Constant.int 0 ], M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |) |) ] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "x2" |); M.get_name (| globals, "f2" |); M.get_name (| globals, "d2" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "x2" |); M.get_name (| globals, locals_stack, "f2" |); M.get_name (| globals, locals_stack, "d2" |) ], make_tuple [ M.call (| - M.get_name (| globals, "list" |), + M.get_name (| globals, locals_stack, "list" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); BinOp.add (| @@ -1415,9 +1466,9 @@ Definition GaloisField : Value.t := ], BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), @@ -1425,7 +1476,7 @@ Definition GaloisField : Value.t := |) |) |); M.call (| - M.get_field (| M.get_name (| globals, "self" |), "deg" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "deg" |), make_list [], make_dict [] |) ] @@ -1433,119 +1484,119 @@ Definition GaloisField : Value.t := let _ := M.assign_local (| "q_0" , M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x2" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "x2" |), + M.get_name (| globals, locals_stack, "d2" |) |); UnOp.sub (| Constant.int 1 |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d2" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "x1" |), + M.get_name (| globals, locals_stack, "x1" |), BinOp.sub (| BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x1" |) + M.get_name (| globals, locals_stack, "x1" |) ], make_dict [] |) |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d2" |) |) |), BinOp.mod_ (| BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "x1" |), + M.get_name (| globals, locals_stack, "x1" |), BinOp.sub (| BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x1" |) + M.get_name (| globals, locals_stack, "x1" |) ], make_dict [] |) |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d2" |) |) |), BinOp.mult (| - M.get_name (| globals, "q_0" |), + M.get_name (| globals, locals_stack, "q_0" |), M.get_subscript (| - M.get_name (| globals, "x2" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x2" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |), - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "f1" |), + M.get_name (| globals, locals_stack, "f1" |), BinOp.sub (| BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x1" |) + M.get_name (| globals, locals_stack, "x1" |) ], make_dict [] |) |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d2" |) |) |), BinOp.mod_ (| BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "f1" |), + M.get_name (| globals, locals_stack, "f1" |), BinOp.sub (| BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x1" |) + M.get_name (| globals, locals_stack, "x1" |) ], make_dict [] |) |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d2" |) |) |), BinOp.mult (| - M.get_name (| globals, "q_0" |), + M.get_name (| globals, locals_stack, "q_0" |), M.get_subscript (| - M.get_name (| globals, "f2" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "f2" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |), - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) |) |) in M.pure Constant.None_ @@ -1556,15 +1607,15 @@ Definition GaloisField : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) ], make_dict [] |), @@ -1581,8 +1632,8 @@ Definition GaloisField : Value.t := M.if_then_else (| Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "x1" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x1" |), + M.get_name (| globals, locals_stack, "i" |) |), Constant.int 0 |), @@ -1590,7 +1641,7 @@ Definition GaloisField : Value.t := ltac:(M.monadic ( let _ := M.assign_local (| "d1" , - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in let _ := M.break (| |) in M.pure Constant.None_ @@ -1612,40 +1663,40 @@ Definition GaloisField : Value.t := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "d1" |), + M.get_name (| globals, locals_stack, "d1" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "ans" , - M.get_name (| globals, "f1" |) + M.get_name (| globals, locals_stack, "f1" |) |) in let _ := M.assign_local (| "q" , M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x1" |), + M.get_name (| globals, locals_stack, "x1" |), Constant.int 0 |); UnOp.sub (| Constant.int 1 |); - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ans" |) + M.get_name (| globals, locals_stack, "ans" |) ], make_dict [] |) @@ -1656,10 +1707,10 @@ Definition GaloisField : Value.t := let _ := M.assign_op (| BinOp.mult, M.get_subscript (| - M.get_name (| globals, "ans" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "ans" |), + M.get_name (| globals, locals_stack, "i" |) |), - M.get_name (| globals, "q" |) + M.get_name (| globals, locals_stack, "q" |) |) in M.pure Constant.None_ )), @@ -1675,40 +1726,40 @@ Definition GaloisField : Value.t := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "d2" |), + M.get_name (| globals, locals_stack, "d2" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "ans" , - M.get_name (| globals, "f2" |) + M.get_name (| globals, locals_stack, "f2" |) |) in let _ := M.assign_local (| "q" , M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x2" |), + M.get_name (| globals, locals_stack, "x2" |), Constant.int 0 |); UnOp.sub (| Constant.int 1 |); - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ans" |) + M.get_name (| globals, locals_stack, "ans" |) ], make_dict [] |) @@ -1719,7 +1770,7 @@ Definition GaloisField : Value.t := let _ := M.assign_op_local (| BinOp.mult, "ans", - M.get_name (| globals, "q" |) + M.get_name (| globals, locals_stack, "q" |) |) in M.pure Constant.None_ )), @@ -1739,8 +1790,8 @@ Definition GaloisField : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "d1" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d1" |), + M.get_name (| globals, locals_stack, "d2" |) |), (* then *) ltac:(M.monadic ( @@ -1748,18 +1799,18 @@ Definition GaloisField : Value.t := "q" , BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "x2" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "x2" |), + M.get_name (| globals, locals_stack, "d2" |) |), M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x1" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "x1" |), + M.get_name (| globals, locals_stack, "d1" |) |); UnOp.sub (| Constant.int 1 |); - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) ], make_dict [] |) @@ -1767,21 +1818,21 @@ Definition GaloisField : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) ], make_dict [] |), BinOp.sub (| - M.get_name (| globals, "d2" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "d2" |), + M.get_name (| globals, locals_stack, "d1" |) |) |) ], @@ -1790,70 +1841,70 @@ Definition GaloisField : Value.t := ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "x2" |), + M.get_name (| globals, locals_stack, "x2" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d2" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "d2" |), + M.get_name (| globals, locals_stack, "d1" |) |) |) |), BinOp.mod_ (| BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "x2" |), + M.get_name (| globals, locals_stack, "x2" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d2" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "d2" |), + M.get_name (| globals, locals_stack, "d1" |) |) |) |), BinOp.mult (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.get_subscript (| - M.get_name (| globals, "x1" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x1" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |), - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "f2" |), + M.get_name (| globals, locals_stack, "f2" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d2" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "d2" |), + M.get_name (| globals, locals_stack, "d1" |) |) |) |), BinOp.mod_ (| BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "f2" |), + M.get_name (| globals, locals_stack, "f2" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d2" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "d2" |), + M.get_name (| globals, locals_stack, "d1" |) |) |) |), BinOp.mult (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.get_subscript (| - M.get_name (| globals, "f1" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "f1" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |), - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) |) |) in M.pure Constant.None_ @@ -1866,8 +1917,8 @@ Definition GaloisField : Value.t := M.while (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "x2" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "x2" |), + M.get_name (| globals, locals_stack, "d2" |) |), Constant.int 0 |), @@ -1890,18 +1941,18 @@ Definition GaloisField : Value.t := "q" , BinOp.mult (| M.get_subscript (| - M.get_name (| globals, "x1" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "x1" |), + M.get_name (| globals, locals_stack, "d1" |) |), M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ M.get_subscript (| - M.get_name (| globals, "x2" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "x2" |), + M.get_name (| globals, locals_stack, "d2" |) |); UnOp.sub (| Constant.int 1 |); - M.get_field (| M.get_name (| globals, "self" |), "PRIME" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "PRIME" |) ], make_dict [] |) @@ -1909,21 +1960,21 @@ Definition GaloisField : Value.t := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) ], make_dict [] |), BinOp.sub (| - M.get_name (| globals, "d1" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d1" |), + M.get_name (| globals, locals_stack, "d2" |) |) |) ], @@ -1932,70 +1983,70 @@ Definition GaloisField : Value.t := ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "x1" |), + M.get_name (| globals, locals_stack, "x1" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d1" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d1" |), + M.get_name (| globals, locals_stack, "d2" |) |) |) |), BinOp.mod_ (| BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "x1" |), + M.get_name (| globals, locals_stack, "x1" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d1" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d1" |), + M.get_name (| globals, locals_stack, "d2" |) |) |) |), BinOp.mult (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.get_subscript (| - M.get_name (| globals, "x2" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x2" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |), - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) |) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "f1" |), + M.get_name (| globals, locals_stack, "f1" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d1" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d1" |), + M.get_name (| globals, locals_stack, "d2" |) |) |) |), BinOp.mod_ (| BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "f1" |), + M.get_name (| globals, locals_stack, "f1" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.sub (| - M.get_name (| globals, "d1" |), - M.get_name (| globals, "d2" |) + M.get_name (| globals, locals_stack, "d1" |), + M.get_name (| globals, locals_stack, "d2" |) |) |) |), BinOp.mult (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.get_subscript (| - M.get_name (| globals, "f2" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "f2" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |), - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "p" |) |) |) in M.pure Constant.None_ @@ -2008,8 +2059,8 @@ Definition GaloisField : Value.t := M.while (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "x1" |), - M.get_name (| globals, "d1" |) + M.get_name (| globals, locals_stack, "x1" |), + M.get_name (| globals, locals_stack, "d1" |) |), Constant.int 0 |), @@ -2035,16 +2086,16 @@ Definition GaloisField : Value.t := |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); - M.get_name (| globals, "ans" |) + M.get_name (| globals, locals_stack, "ans" |) ], make_dict [] |) @@ -2053,14 +2104,15 @@ Definition GaloisField : Value.t := ); ( "__pow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "exponent" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "exponent" ] in + ltac:(M.monadic ( let _ := M.assign_local (| "degree" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "MODULUS" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "MODULUS" |) ], make_dict [] |) @@ -2069,7 +2121,7 @@ Definition GaloisField : Value.t := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "exponent" |), + M.get_name (| globals, locals_stack, "exponent" |), Constant.int 0 |), (* then *) @@ -2077,14 +2129,14 @@ Definition GaloisField : Value.t := let _ := M.assign_local (| "self" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "multiplicative_inverse" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "multiplicative_inverse" |), make_list [], make_dict [] |) |) in let _ := M.assign_local (| "exponent" , - UnOp.sub (| M.get_name (| globals, "exponent" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "exponent" |) |) |) in M.pure Constant.None_ (* else *) @@ -2094,12 +2146,12 @@ Definition GaloisField : Value.t := let _ := M.assign_local (| "res" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__new__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__new__" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |); @@ -2112,7 +2164,7 @@ Definition GaloisField : Value.t := Constant.int 0 ], BinOp.sub (| - M.get_name (| globals, "degree" |), + M.get_name (| globals, locals_stack, "degree" |), Constant.int 1 |) |) @@ -2123,12 +2175,12 @@ Definition GaloisField : Value.t := |) in let _ := M.assign_local (| "s" , - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) |) in let _ := M.while (| Compare.not_eq (| - M.get_name (| globals, "exponent" |), + M.get_name (| globals, locals_stack, "exponent" |), Constant.int 0 |), ltac:(M.monadic ( @@ -2137,7 +2189,7 @@ Definition GaloisField : Value.t := M.if_then_else (| Compare.eq (| BinOp.mod_ (| - M.get_name (| globals, "exponent" |), + M.get_name (| globals, locals_stack, "exponent" |), Constant.int 2 |), Constant.int 1 @@ -2147,7 +2199,7 @@ Definition GaloisField : Value.t := let _ := M.assign_op_local (| BinOp.mult, "res", - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |) in M.pure Constant.None_ (* else *) @@ -2157,7 +2209,7 @@ Definition GaloisField : Value.t := let _ := M.assign_op_local (| BinOp.mult, "s", - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |) in let _ := M.assign_op_local (| BinOp.floor_div, @@ -2171,19 +2223,20 @@ Definition GaloisField : Value.t := )) |) in let _ := M.return_ (| - M.get_name (| globals, "res" |) + M.get_name (| globals, locals_stack, "res" |) |) in M.pure Constant.None_)) ); ( "__ipow__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "right" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "right" ] in + ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "self" |), "__pow__" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "__pow__" |), make_list [ - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "right" |) ], make_dict [] |) @@ -2192,8 +2245,9 @@ Definition GaloisField : Value.t := ); ( "frobenius", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns `self ** p`. This function is known as the Frobenius endomorphism and has many special mathematical properties. In @@ -2203,7 +2257,7 @@ Definition GaloisField : Value.t := let _ := M.assign_local (| "ans" , M.call (| - M.get_field (| M.get_name (| globals, "self" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "from_int" |), make_list [ Constant.int 0 ], @@ -2213,11 +2267,11 @@ Definition GaloisField : Value.t := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "a" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "a" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "self" |) + M.get_name (| globals, locals_stack, "self" |) ], make_dict [] |), @@ -2227,18 +2281,18 @@ Definition GaloisField : Value.t := "ans", M.call (| M.get_field (| M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_name (| globals, "U" |); + M.get_name (| globals, locals_stack, "U" |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "self" |), "FROBENIUS_COEFFICIENTS" |), - M.get_name (| globals, "i" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "FROBENIUS_COEFFICIENTS" |), + M.get_name (| globals, locals_stack, "i" |) |) ], make_dict [] |), "scalar_mul" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -2250,7 +2304,7 @@ Definition GaloisField : Value.t := )) |) in let _ := M.return_ (| - M.get_name (| globals, "ans" |) + M.get_name (| globals, locals_stack, "ans" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/crypto/hash.v b/CoqOfPython/ethereum/crypto/hash.v index ffb11bc..9f684cc 100644 --- a/CoqOfPython/ethereum/crypto/hash.v +++ b/CoqOfPython/ethereum/crypto/hash.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.crypto.hash". +Definition globals : Globals.t := "ethereum.crypto.hash". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,16 +30,17 @@ Axiom ethereum_base_types_imports_Bytes64 : IsImported globals "ethereum.base_types" "Bytes64". Definition Hash32 : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes32" |) + M.get_name (| globals, locals_stack, "Bytes32" |) )). Definition Hash64 : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes64" |) + M.get_name (| globals, locals_stack, "Bytes64" |) )). Definition keccak256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the keccak256 hash of the input `buffer`. @@ -54,20 +57,20 @@ Definition keccak256 : Value.t -> Value.t -> M := let _ := M.assign_local (| "k" , M.call (| - M.get_field (| M.get_name (| globals, "keccak" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "keccak" |), "new" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "k" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "k" |), "update" |), make_list [ - M.get_name (| globals, "buffer" |) + M.get_name (| globals, locals_stack, "buffer" |) ], make_dict [] |), "digest" |), @@ -81,8 +84,9 @@ Definition keccak256 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition keccak512 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the keccak512 hash of the input `buffer`. @@ -99,20 +103,20 @@ Definition keccak512 : Value.t -> Value.t -> M := let _ := M.assign_local (| "k" , M.call (| - M.get_field (| M.get_name (| globals, "keccak" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "keccak" |), "new" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Hash64" |), + M.get_name (| globals, locals_stack, "Hash64" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "k" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "k" |), "update" |), make_list [ - M.get_name (| globals, "buffer" |) + M.get_name (| globals, locals_stack, "buffer" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/dao_fork/__init__.v b/CoqOfPython/ethereum/dao_fork/__init__.v index 12b0f7a..616799d 100644 --- a/CoqOfPython/ethereum/dao_fork/__init__.v +++ b/CoqOfPython/ethereum/dao_fork/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.__init__". +Definition globals : Globals.t := "ethereum.dao_fork.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -14,7 +16,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 1920000 ], diff --git a/CoqOfPython/ethereum/dao_fork/blocks.v b/CoqOfPython/ethereum/dao_fork/blocks.v index 0707efe..ddecfb8 100644 --- a/CoqOfPython/ethereum/dao_fork/blocks.v +++ b/CoqOfPython/ethereum/dao_fork/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.blocks". +Definition globals : Globals.t := "ethereum.dao_fork.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/dao_fork/bloom.v b/CoqOfPython/ethereum/dao_fork/bloom.v index 4b83130..59b1869 100644 --- a/CoqOfPython/ethereum/dao_fork/bloom.v +++ b/CoqOfPython/ethereum/dao_fork/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.bloom". +Definition globals : Globals.t := "ethereum.dao_fork.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_dao_fork_fork_types_imports_Bloom : IsImported globals "ethereum.dao_fork.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/dao.v b/CoqOfPython/ethereum/dao_fork/dao.v index 160f310..434d57c 100644 --- a/CoqOfPython/ethereum/dao_fork/dao.v +++ b/CoqOfPython/ethereum/dao_fork/dao.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.dao". +Definition globals : Globals.t := "ethereum.dao_fork.dao". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,7 +38,7 @@ Definition DAO_ACCOUNTS : Value.t := M.run ltac:(M.monadic ( Definition DAO_RECOVERY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0xbf4ed7b27f1d666546e30d74d50d173d20bca754" ], @@ -45,8 +47,9 @@ Definition DAO_RECOVERY : Value.t := M.run ltac:(M.monadic ( )). Definition apply_dao : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Apply the dao fork to the state. @@ -57,27 +60,27 @@ Definition apply_dao : Value.t -> Value.t -> M := " in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_name (| globals, "DAO_ACCOUNTS" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_name (| globals, locals_stack, "DAO_ACCOUNTS" |), ltac:(M.monadic ( let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "DAO_RECOVERY" |); - M.get_name (| globals, "balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "DAO_RECOVERY" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/dao_fork/fork.v b/CoqOfPython/ethereum/dao_fork/fork.v index cd0c092..4f769f4 100644 --- a/CoqOfPython/ethereum/dao_fork/fork.v +++ b/CoqOfPython/ethereum/dao_fork/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.fork". +Definition globals : Globals.t := "ethereum.dao_fork.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -141,7 +143,7 @@ Axiom ethereum_dao_fork_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 5, @@ -165,7 +167,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -188,8 +190,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -216,20 +219,21 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.call (| - M.get_name (| globals, "apply_dao" |), + M.get_name (| globals, locals_stack, "apply_dao" |), make_list [ - M.get_field (| M.get_name (| globals, "old" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "old" |), "state" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -252,7 +256,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -263,9 +267,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -287,17 +291,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -310,13 +314,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -327,20 +331,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -365,110 +370,110 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -477,9 +482,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -488,9 +493,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -504,8 +509,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -524,95 +530,95 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -621,13 +627,13 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -636,14 +642,14 @@ Definition validate_header : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.gt_e (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), - M.get_field (| M.get_name (| globals, "FORK_CRITERIA" |), "block_number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "FORK_CRITERIA" |), "block_number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "FORK_CRITERIA" |), "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "FORK_CRITERIA" |), "block_number" |), Constant.int 10 |) |) @@ -652,13 +658,13 @@ Definition validate_header : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |), Constant.bytes "64616f2d686172642d666f726b" |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -668,17 +674,18 @@ Definition validate_header : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -704,26 +711,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -731,8 +738,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -750,9 +758,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -760,25 +768,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -787,41 +795,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -843,34 +852,35 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -894,13 +904,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -915,8 +925,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -957,50 +968,50 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |) ], make_dict [] |) @@ -1008,18 +1019,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1027,55 +1038,55 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); + M.get_name (| globals, locals_stack, "tx" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1084,56 +1095,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1144,8 +1155,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1170,27 +1182,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1199,9 +1211,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1219,46 +1231,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1269,19 +1281,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1290,23 +1302,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1314,16 +1326,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1337,13 +1349,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1358,11 +1370,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1370,88 +1382,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1464,8 +1476,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1494,44 +1507,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1543,19 +1556,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1568,8 +1581,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1597,30 +1611,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1628,98 +1642,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1727,10 +1741,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1738,20 +1752,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1760,10 +1774,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1771,41 +1785,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1813,35 +1827,35 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1852,13 +1866,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1887,17 +1902,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1912,8 +1927,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1942,14 +1958,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -1957,7 +1973,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -1965,7 +1981,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -1979,9 +1995,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -1992,7 +2008,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2005,14 +2021,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -2021,8 +2037,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2043,84 +2060,84 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash" |), + M.get_name (| globals, locals_stack, "signing_hash" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2130,13 +2147,13 @@ Definition recover_sender : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2151,8 +2168,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in the signature. @@ -2172,12 +2190,12 @@ Definition signing_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2188,8 +2206,9 @@ Definition signing_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2223,12 +2242,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2239,8 +2258,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2271,18 +2291,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2299,10 +2319,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2319,8 +2339,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2338,8 +2358,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2381,26 +2402,26 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| Constant.int 1, BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2418,13 +2439,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2432,9 +2453,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.sub (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), @@ -2447,7 +2468,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2457,7 +2478,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2467,13 +2488,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/fork_types.v b/CoqOfPython/ethereum/dao_fork/fork_types.v index 7d58b79..b3f985f 100644 --- a/CoqOfPython/ethereum/dao_fork/fork_types.v +++ b/CoqOfPython/ethereum/dao_fork/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.fork_types". +Definition globals : Globals.t := "ethereum.dao_fork.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/dao_fork/state.v b/CoqOfPython/ethereum/dao_fork/state.v index c526dbf..5204480 100644 --- a/CoqOfPython/ethereum/dao_fork/state.v +++ b/CoqOfPython/ethereum/dao_fork/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.state". +Definition globals : Globals.t := "ethereum.dao_fork.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,28 +710,29 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -724,36 +742,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -770,19 +790,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -798,21 +819,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -824,8 +845,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -839,19 +861,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -868,19 +891,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -895,11 +919,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/dao_fork/transactions.v b/CoqOfPython/ethereum/dao_fork/transactions.v index c515aad..3da1347 100644 --- a/CoqOfPython/ethereum/dao_fork/transactions.v +++ b/CoqOfPython/ethereum/dao_fork/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.transactions". +Definition globals : Globals.t := "ethereum.dao_fork.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/dao_fork/trie.v b/CoqOfPython/ethereum/dao_fork/trie.v index 77ab51e..b30178b 100644 --- a/CoqOfPython/ethereum/dao_fork/trie.v +++ b/CoqOfPython/ethereum/dao_fork/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.trie". +Definition globals : Globals.t := "ethereum.dao_fork.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_dao_fork_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/utils/__init__.v b/CoqOfPython/ethereum/dao_fork/utils/__init__.v index dbf11fc..f7904df 100644 --- a/CoqOfPython/ethereum/dao_fork/utils/__init__.v +++ b/CoqOfPython/ethereum/dao_fork/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.utils.__init__". +Definition globals : Globals.t := "ethereum.dao_fork.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/dao_fork/utils/address.v b/CoqOfPython/ethereum/dao_fork/utils/address.v index 43700aa..eb0718c 100644 --- a/CoqOfPython/ethereum/dao_fork/utils/address.v +++ b/CoqOfPython/ethereum/dao_fork/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.utils.address". +Definition globals : Globals.t := "ethereum.dao_fork.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,8 +40,9 @@ Axiom ethereum_dao_fork_fork_types_imports_Address : IsImported globals "ethereum.dao_fork.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -55,11 +58,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -74,8 +77,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -95,14 +99,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -114,7 +118,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -123,9 +127,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -133,9 +137,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/utils/hexadecimal.v b/CoqOfPython/ethereum/dao_fork/utils/hexadecimal.v index 3f19f3d..c421859 100644 --- a/CoqOfPython/ethereum/dao_fork/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/dao_fork/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.dao_fork.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_dao_fork_fork_types_imports_Root : IsImported globals "ethereum.dao_fork.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/dao_fork/utils/message.v b/CoqOfPython/ethereum/dao_fork/utils/message.v index 9520a0a..c21cee2 100644 --- a/CoqOfPython/ethereum/dao_fork/utils/message.v +++ b/CoqOfPython/ethereum/dao_fork/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.utils.message". +Definition globals : Globals.t := "ethereum.dao_fork.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,8 +48,9 @@ Axiom ethereum_dao_fork_utils_address_imports_compute_contract_address : IsImported globals "ethereum.dao_fork.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -81,10 +84,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -93,20 +96,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -120,7 +123,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -129,7 +132,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -138,10 +141,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -149,19 +152,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -170,14 +173,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -188,7 +191,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -200,7 +203,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/vm/__init__.v b/CoqOfPython/ethereum/dao_fork/vm/__init__.v index 7a3276a..26cdbbe 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/__init__.v +++ b/CoqOfPython/ethereum/dao_fork/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.__init__". +Definition globals : Globals.t := "ethereum.dao_fork.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -88,8 +90,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -102,24 +105,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -132,7 +136,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/exceptions.v b/CoqOfPython/ethereum/dao_fork/vm/exceptions.v index 193cc22..8544beb 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/exceptions.v +++ b/CoqOfPython/ethereum/dao_fork/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.exceptions". +Definition globals : Globals.t := "ethereum.dao_fork.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -69,22 +71,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/dao_fork/vm/gas.v b/CoqOfPython/ethereum/dao_fork/vm/gas.v index 7739073..5fa4e93 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/gas.v +++ b/CoqOfPython/ethereum/dao_fork/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.gas". +Definition globals : Globals.t := "ethereum.dao_fork.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -54,7 +56,7 @@ Axiom ethereum_dao_fork_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -64,7 +66,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -74,7 +76,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -84,7 +86,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -94,7 +96,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -104,7 +106,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -114,7 +116,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -124,7 +126,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -134,7 +136,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -144,7 +146,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -154,7 +156,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -164,7 +166,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -174,7 +176,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -184,7 +186,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -194,7 +196,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -204,7 +206,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -214,7 +216,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -224,7 +226,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -234,7 +236,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -244,7 +246,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -254,7 +256,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -264,7 +266,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -274,7 +276,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -284,7 +286,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -294,7 +296,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -304,7 +306,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 40 ], @@ -314,7 +316,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -324,7 +326,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -334,7 +336,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -344,7 +346,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -354,7 +356,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -364,7 +366,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -374,7 +376,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -384,7 +386,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -394,7 +396,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -404,7 +406,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -414,7 +416,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -443,8 +445,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -457,13 +460,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -474,22 +477,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -499,8 +502,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -520,9 +524,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -532,15 +536,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -549,16 +553,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -577,7 +582,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -587,7 +592,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -597,12 +602,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -612,14 +617,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -633,9 +638,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -643,20 +648,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -669,8 +674,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -684,16 +689,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -701,9 +706,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -712,13 +717,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -728,10 +733,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -739,8 +744,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "gas"; "to"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "gas"; "to"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount for executing Opcodes `CALL` and `CALLCODE`. @@ -764,17 +770,17 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -782,7 +788,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -790,13 +796,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -804,7 +810,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| @@ -812,12 +818,12 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "gas" |) |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) |) in let _ := M.assign_local (| @@ -825,26 +831,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( -M.get_name (| globals, "gas" |) +M.get_name (| globals, locals_stack, "gas" |) (* else *) )), ltac:(M.monadic ( BinOp.add (| - M.get_name (| globals, "GAS_CALL_STIPEND" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |), + M.get_name (| globals, locals_stack, "gas" |) |) )) |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ - M.get_name (| globals, "cost" |); - M.get_name (| globals, "stipend" |) + M.get_name (| globals, locals_stack, "cost" |); + M.get_name (| globals, locals_stack, "stipend" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/__init__.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/__init__.v index ca3f554..e8eadb1 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/arithmetic.v index c64126f..df4766a 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/bitwise.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/bitwise.v index fccfa0d..4e056ea 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,42 +62,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -108,9 +112,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,42 +122,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -167,9 +172,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -177,42 +182,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -226,39 +232,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -273,9 +280,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -283,18 +290,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -302,7 +309,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -310,7 +317,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -324,15 +331,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -340,16 +347,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -357,16 +364,16 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/block.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/block.v index 5a65267..6cf1947 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/block.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.block". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/comparison.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/comparison.v index 48940ed..d8563d6 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/control_flow.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/control_flow.v index 2242d7f..9eaff64 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/environment.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/environment.v index 42b1678..9c28d5a 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -60,8 +62,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -73,21 +76,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -96,14 +99,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -116,12 +120,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -130,42 +134,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -178,21 +183,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -201,14 +206,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -220,21 +226,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -243,14 +249,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -262,31 +269,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -300,30 +308,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -334,13 +342,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -349,14 +357,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -368,24 +377,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -397,14 +406,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -420,9 +430,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -430,9 +440,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -440,9 +450,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -451,12 +461,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -469,76 +479,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -550,24 +561,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -579,14 +590,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -602,9 +614,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -612,9 +624,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -622,9 +634,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -633,12 +645,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -651,76 +663,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -732,21 +745,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -755,14 +768,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -775,12 +789,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -789,26 +803,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -820,23 +834,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -849,12 +864,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -865,9 +880,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -875,9 +890,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -885,9 +900,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -896,12 +911,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -914,52 +929,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -967,27 +982,27 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/keccak.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/keccak.v index 3205868..5d1d7bb 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/log.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/log.v index 47d5c73..04aa853 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/log.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.log". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_pop : IsImported globals "ethereum.dao_fork.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -66,9 +69,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -89,11 +92,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -102,9 +105,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -113,9 +116,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -128,74 +131,74 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -203,9 +206,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -213,9 +216,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -223,9 +226,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -233,9 +236,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/memory.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/memory.v index 45dbf56..7d3e36c 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/stack.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/stack.v index 2ee7ab3..c196941 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_dao_fork_vm_memory_imports_buffer_read : IsImported globals "ethereum.dao_fork.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/storage.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/storage.v index de11f5d..7039b79 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,8 +44,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -58,9 +61,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -69,43 +72,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -119,9 +123,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -132,9 +136,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,11 +146,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -156,12 +160,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -170,14 +174,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -186,12 +190,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -200,8 +204,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -209,26 +213,26 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/instructions/system.v b/CoqOfPython/ethereum/dao_fork/vm/instructions/system.v index 47ad133..c356eeb 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/instructions/system.v +++ b/CoqOfPython/ethereum/dao_fork/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.instructions.system". +Definition globals : Globals.t := "ethereum.dao_fork.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_dao_fork_vm_stack_imports_push : IsImported globals "ethereum.dao_fork.vm.stack" "push". Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -90,9 +93,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -100,9 +103,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -110,9 +113,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,35 +123,35 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -157,23 +160,23 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -181,14 +184,14 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -201,15 +204,15 @@ Definition create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -225,10 +228,10 @@ Definition create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -237,11 +240,11 @@ Definition create : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -252,8 +255,8 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in M.pure Constant.None_ (* else *) @@ -262,29 +265,29 @@ Definition create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -299,27 +302,27 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -327,10 +330,10 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -338,23 +341,23 @@ Definition create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -367,21 +370,21 @@ Definition create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -396,14 +399,15 @@ Definition create : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -415,9 +419,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -425,9 +429,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -435,57 +439,58 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in @@ -495,24 +500,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -532,11 +537,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -544,10 +549,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -555,7 +560,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -563,10 +568,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -574,23 +579,23 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -603,19 +608,19 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -629,16 +634,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -650,14 +655,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -666,8 +671,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -679,12 +685,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -695,12 +701,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -711,9 +717,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -721,9 +727,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -731,9 +737,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -741,9 +747,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -751,9 +757,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -761,12 +767,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -775,42 +781,42 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -819,17 +825,17 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -840,26 +846,26 @@ Definition call : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -867,14 +873,15 @@ Definition call : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -886,12 +893,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -902,12 +909,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -918,9 +925,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -928,9 +935,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -938,9 +945,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -948,9 +955,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -958,26 +965,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -986,42 +993,42 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1030,17 +1037,17 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1051,26 +1058,26 @@ Definition callcode : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1078,14 +1085,15 @@ Definition callcode : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1097,12 +1105,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1112,37 +1120,37 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_ZERO" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1154,15 +1162,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1170,20 +1178,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1191,33 +1199,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1227,22 +1235,23 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1254,12 +1263,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1270,12 +1279,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1286,9 +1295,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1296,9 +1305,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,9 +1315,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1316,9 +1325,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1326,59 +1335,59 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "gas" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/interpreter.v b/CoqOfPython/ethereum/dao_fork/vm/interpreter.v index 1a01d75..1c5a366 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/interpreter.v +++ b/CoqOfPython/ethereum/dao_fork/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.interpreter". +Definition globals : Globals.t := "ethereum.dao_fork.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -109,7 +111,7 @@ Axiom ethereum_dao_fork_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -128,8 +130,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -151,9 +154,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -165,10 +168,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -176,39 +179,39 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -222,10 +225,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -238,10 +241,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -251,14 +254,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -266,7 +269,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -278,44 +281,44 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -323,8 +326,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -341,19 +345,19 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -361,24 +365,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -386,22 +390,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -421,13 +426,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -439,17 +444,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -457,10 +462,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -468,12 +473,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -485,10 +490,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -496,13 +501,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -510,22 +515,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -543,14 +549,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -558,13 +564,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/memory.v b/CoqOfPython/ethereum/dao_fork/vm/memory.v index d512649..ea3e10e 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/memory.v +++ b/CoqOfPython/ethereum/dao_fork/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.memory". +Definition globals : Globals.t := "ethereum.dao_fork.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/__init__.v index a28f1e8..659ca47 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.dao_fork.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], diff --git a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ecrecover.v index 0c4b624..48739c7 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.dao_fork.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_dao_fork_vm_memory_imports_buffer_read : IsImported globals "ethereum.dao_fork.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/identity.v index 4b71893..1355def 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.dao_fork.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_dao_fork_vm_gas_imports_charge_gas : IsImported globals "ethereum.dao_fork.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/mapping.v index b94fbd8..97f6101 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.dao_fork.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ripemd160.v index 39c8265..df73567 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.dao_fork.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_dao_fork_vm_gas_imports_charge_gas : IsImported globals "ethereum.dao_fork.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/sha256.v index 69f489f..db2377c 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/dao_fork/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.dao_fork.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_dao_fork_vm_gas_imports_charge_gas : IsImported globals "ethereum.dao_fork.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/dao_fork/vm/runtime.v b/CoqOfPython/ethereum/dao_fork/vm/runtime.v index 9c619f3..acf2069 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/runtime.v +++ b/CoqOfPython/ethereum/dao_fork/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.runtime". +Definition globals : Globals.t := "ethereum.dao_fork.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_dao_fork_vm_instructions_imports_Ops : IsImported globals "ethereum.dao_fork.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/dao_fork/vm/stack.v b/CoqOfPython/ethereum/dao_fork/vm/stack.v index b8cc90b..67bc666 100644 --- a/CoqOfPython/ethereum/dao_fork/vm/stack.v +++ b/CoqOfPython/ethereum/dao_fork/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.dao_fork.vm.stack". +Definition globals : Globals.t := "ethereum.dao_fork.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_dao_fork_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.dao_fork.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/ethash.v b/CoqOfPython/ethereum/ethash.v index 59371c7..92b7c5f 100644 --- a/CoqOfPython/ethereum/ethash.v +++ b/CoqOfPython/ethereum/ethash.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.ethash". +Definition globals : Globals.t := "ethereum.ethash". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -194,8 +196,9 @@ Number of accesses in the [`hashimoto`] loop. ". Definition epoch : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the epoch number to which the block identified by `block_number` belongs. The first epoch is numbered zero. @@ -209,15 +212,16 @@ Definition epoch : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.floor_div (| - M.get_name (| globals, "block_number" |), - M.get_name (| globals, "EPOCH_SIZE" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_name (| globals, locals_stack, "EPOCH_SIZE" |) |) |) in M.pure Constant.None_)). Definition cache_size : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the cache size (in bytes) of the epoch to which `block_number` belongs. @@ -238,13 +242,13 @@ Definition cache_size : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , BinOp.add (| - M.get_name (| globals, "INITIAL_CACHE_SIZE" |), + M.get_name (| globals, locals_stack, "INITIAL_CACHE_SIZE" |), BinOp.mult (| - M.get_name (| globals, "CACHE_EPOCH_GROWTH_SIZE" |), + M.get_name (| globals, locals_stack, "CACHE_EPOCH_GROWTH_SIZE" |), M.call (| - M.get_name (| globals, "epoch" |), + M.get_name (| globals, locals_stack, "epoch" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |) @@ -254,16 +258,16 @@ Definition cache_size : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "size", - M.get_name (| globals, "HASH_BYTES" |) + M.get_name (| globals, locals_stack, "HASH_BYTES" |) |) in let _ := M.while (| UnOp.not (| M.call (| - M.get_name (| globals, "is_prime" |), + M.get_name (| globals, locals_stack, "is_prime" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "size" |), - M.get_name (| globals, "HASH_BYTES" |) + M.get_name (| globals, locals_stack, "size" |), + M.get_name (| globals, locals_stack, "HASH_BYTES" |) |) ], make_dict [] @@ -274,7 +278,7 @@ Definition cache_size : Value.t -> Value.t -> M := "size", BinOp.mult (| Constant.int 2, - M.get_name (| globals, "HASH_BYTES" |) + M.get_name (| globals, locals_stack, "HASH_BYTES" |) |) |) in M.pure Constant.None_ @@ -284,13 +288,14 @@ Definition cache_size : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) |) in M.pure Constant.None_)). Definition dataset_size : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the dataset size (in bytes) of the epoch to which `block_number` belongs. @@ -313,13 +318,13 @@ Definition dataset_size : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , BinOp.add (| - M.get_name (| globals, "INITIAL_DATASET_SIZE" |), + M.get_name (| globals, locals_stack, "INITIAL_DATASET_SIZE" |), BinOp.mult (| - M.get_name (| globals, "DATASET_EPOCH_GROWTH_SIZE" |), + M.get_name (| globals, locals_stack, "DATASET_EPOCH_GROWTH_SIZE" |), M.call (| - M.get_name (| globals, "epoch" |), + M.get_name (| globals, locals_stack, "epoch" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |) @@ -329,16 +334,16 @@ Definition dataset_size : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "size", - M.get_name (| globals, "MIX_BYTES" |) + M.get_name (| globals, locals_stack, "MIX_BYTES" |) |) in let _ := M.while (| UnOp.not (| M.call (| - M.get_name (| globals, "is_prime" |), + M.get_name (| globals, locals_stack, "is_prime" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "size" |), - M.get_name (| globals, "MIX_BYTES" |) + M.get_name (| globals, locals_stack, "size" |), + M.get_name (| globals, locals_stack, "MIX_BYTES" |) |) ], make_dict [] @@ -349,7 +354,7 @@ Definition dataset_size : Value.t -> Value.t -> M := "size", BinOp.mult (| Constant.int 2, - M.get_name (| globals, "MIX_BYTES" |) + M.get_name (| globals, locals_stack, "MIX_BYTES" |) |) |) in M.pure Constant.None_ @@ -359,13 +364,14 @@ Definition dataset_size : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) |) in M.pure Constant.None_)). Definition generate_seed : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the cache generation seed for the block identified by `block_number`. See [`generate_cache`]. @@ -375,9 +381,9 @@ Definition generate_seed : Value.t -> Value.t -> M := let _ := M.assign_local (| "epoch_number" , M.call (| - M.get_name (| globals, "epoch" |), + M.get_name (| globals, locals_stack, "epoch" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |) @@ -392,16 +398,16 @@ Definition generate_seed : Value.t -> Value.t -> M := let _ := M.while (| Compare.not_eq (| - M.get_name (| globals, "epoch_number" |), + M.get_name (| globals, locals_stack, "epoch_number" |), Constant.int 0 |), ltac:(M.monadic ( let _ := M.assign_local (| "seed" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "seed" |) + M.get_name (| globals, locals_stack, "seed" |) ], make_dict [] |) @@ -419,9 +425,9 @@ Definition generate_seed : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "seed" |) + M.get_name (| globals, locals_stack, "seed" |) ], make_dict [] |) @@ -429,8 +435,9 @@ Definition generate_seed : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition generate_cache : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate the cache for the block identified by `block_number`. See [`generate_dataset`] for how the cache is used. @@ -446,9 +453,9 @@ Definition generate_cache : Value.t -> Value.t -> M := let _ := M.assign_local (| "seed" , M.call (| - M.get_name (| globals, "generate_seed" |), + M.get_name (| globals, locals_stack, "generate_seed" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |) @@ -456,9 +463,9 @@ Definition generate_cache : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache_size_bytes" , M.call (| - M.get_name (| globals, "cache_size" |), + M.get_name (| globals, locals_stack, "cache_size" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |) @@ -466,17 +473,17 @@ Definition generate_cache : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache_size_words" , BinOp.floor_div (| - M.get_name (| globals, "cache_size_bytes" |), - M.get_name (| globals, "HASH_BYTES" |) + M.get_name (| globals, locals_stack, "cache_size_bytes" |), + M.get_name (| globals, locals_stack, "HASH_BYTES" |) |) |) in let _ := M.assign_local (| "cache" , make_list [ M.call (| - M.get_name (| globals, "keccak512" |), + M.get_name (| globals, locals_stack, "keccak512" |), make_list [ - M.get_name (| globals, "seed" |) + M.get_name (| globals, locals_stack, "seed" |) ], make_dict [] |) @@ -484,12 +491,12 @@ Definition generate_cache : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "index" |), + M.get_name (| globals, locals_stack, "index" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; - M.get_name (| globals, "cache_size_words" |) + M.get_name (| globals, locals_stack, "cache_size_words" |) ], make_dict [] |), @@ -497,12 +504,12 @@ Definition generate_cache : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache_item" , M.call (| - M.get_name (| globals, "keccak512" |), + M.get_name (| globals, locals_stack, "keccak512" |), make_list [ M.get_subscript (| - M.get_name (| globals, "cache" |), + M.get_name (| globals, locals_stack, "cache" |), BinOp.sub (| - M.get_name (| globals, "index" |), + M.get_name (| globals, locals_stack, "index" |), Constant.int 1 |) |) @@ -511,9 +518,9 @@ Definition generate_cache : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "cache" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "cache" |), "append" |), make_list [ - M.get_name (| globals, "cache_item" |) + M.get_name (| globals, locals_stack, "cache_item" |) ], make_dict [] |) in @@ -525,22 +532,22 @@ Definition generate_cache : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "CACHE_ROUNDS" |) + M.get_name (| globals, locals_stack, "CACHE_ROUNDS" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.for_ (| - M.get_name (| globals, "index" |), + M.get_name (| globals, locals_stack, "index" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "cache_size_words" |) + M.get_name (| globals, locals_stack, "cache_size_words" |) ], make_dict [] |), @@ -548,37 +555,37 @@ Definition generate_cache : Value.t -> Value.t -> M := let _ := M.assign_local (| "first_cache_item" , M.get_subscript (| - M.get_name (| globals, "cache" |), + M.get_name (| globals, locals_stack, "cache" |), BinOp.mod_ (| BinOp.add (| BinOp.sub (| - M.get_name (| globals, "index" |), + M.get_name (| globals, locals_stack, "index" |), Constant.int 1 |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "cache_size_words" |) + M.get_name (| globals, locals_stack, "cache_size_words" |) ], make_dict [] |) |), - M.get_name (| globals, "cache_size_words" |) + M.get_name (| globals, locals_stack, "cache_size_words" |) |) |) |) in let _ := M.assign_local (| "second_cache_item" , M.get_subscript (| - M.get_name (| globals, "cache" |), + M.get_name (| globals, locals_stack, "cache" |), BinOp.mod_ (| M.call (| - M.get_field (| M.get_name (| globals, "U32" |), "from_le_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U32" |), "from_le_bytes" |), make_list [ M.slice (| M.get_subscript (| - M.get_name (| globals, "cache" |), - M.get_name (| globals, "index" |) + M.get_name (| globals, locals_stack, "cache" |), + M.get_name (| globals, locals_stack, "index" |) |), Constant.int 0, Constant.int 4, @@ -587,14 +594,14 @@ Definition generate_cache : Value.t -> Value.t -> M := ], make_dict [] |), - M.get_name (| globals, "cache_size_words" |) + M.get_name (| globals, locals_stack, "cache_size_words" |) |) |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)" ], @@ -603,13 +610,13 @@ Definition generate_cache : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "cache" |), - M.get_name (| globals, "index" |) + M.get_name (| globals, locals_stack, "cache" |), + M.get_name (| globals, locals_stack, "index" |) |), M.call (| - M.get_name (| globals, "keccak512" |), + M.get_name (| globals, locals_stack, "keccak512" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) @@ -628,7 +635,7 @@ Definition generate_cache : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ Constant.str "(* At expr: unsupported node type: GeneratorExp *)" ], @@ -638,8 +645,9 @@ Definition generate_cache : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition fnv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " A non-associative substitute for XOR, inspired by the [FNV] hash by Fowler, Noll, and Vo. See [`fnv_hash`], [`generate_dataset_item`], and @@ -661,30 +669,30 @@ Definition fnv : Value.t -> Value.t -> M := BinOp.bit_xor (| BinOp.mult (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |), Constant.int 16777619 |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) |), - M.get_field (| M.get_name (| globals, "U32" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U32" |), "MAX_VALUE" |) |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "U32" |), + M.get_name (| globals, locals_stack, "U32" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) @@ -692,8 +700,9 @@ Definition fnv : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition fnv_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "mix_integers"; "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "mix_integers"; "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Combines `data` into `mix_integers` using [`fnv`]. See [`hashimoto`] and [`generate_dataset_item`]. @@ -704,7 +713,7 @@ Definition fnv_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ Constant.str "(* At expr: unsupported node type: GeneratorExp *)" ], @@ -714,8 +723,9 @@ Definition fnv_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition generate_dataset_item : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cache"; "index" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cache"; "index" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate a particular dataset item 0-indexed by `index` by hashing pseudorandomly-selected entries from `cache` together. See [`fnv`] and @@ -731,21 +741,21 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := let _ := M.assign_local (| "mix" , M.call (| - M.get_name (| globals, "keccak512" |), + M.get_name (| globals, locals_stack, "keccak512" |), make_list [ M.call (| M.get_field (| BinOp.bit_xor (| M.call (| - M.get_name (| globals, "le_uint32_sequence_to_uint" |), + M.get_name (| globals, locals_stack, "le_uint32_sequence_to_uint" |), make_list [ M.get_subscript (| - M.get_name (| globals, "cache" |), + M.get_name (| globals, locals_stack, "cache" |), BinOp.mod_ (| - M.get_name (| globals, "index" |), + M.get_name (| globals, locals_stack, "index" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "cache" |) + M.get_name (| globals, locals_stack, "cache" |) ], make_dict [] |) @@ -754,7 +764,7 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := ], make_dict [] |), - M.get_name (| globals, "index" |) + M.get_name (| globals, locals_stack, "index" |) |), "to_le_bytes" |), make_list [], make_dict [] @@ -766,20 +776,20 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := let _ := M.assign_local (| "mix_integers" , M.call (| - M.get_name (| globals, "le_bytes_to_uint32_sequence" |), + M.get_name (| globals, locals_stack, "le_bytes_to_uint32_sequence" |), make_list [ - M.get_name (| globals, "mix" |) + M.get_name (| globals, locals_stack, "mix" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "DATASET_PARENTS" |) + M.get_name (| globals, locals_stack, "DATASET_PARENTS" |) ], make_dict [] |), @@ -789,20 +799,20 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := "cache_index" , BinOp.mod_ (| M.call (| - M.get_name (| globals, "fnv" |), + M.get_name (| globals, locals_stack, "fnv" |), make_list [ BinOp.bit_xor (| - M.get_name (| globals, "index" |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "index" |), + M.get_name (| globals, locals_stack, "j" |) |); - M.get_name (| globals, "mix_word" |) + M.get_name (| globals, locals_stack, "mix_word" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "cache" |) + M.get_name (| globals, locals_stack, "cache" |) ], make_dict [] |) @@ -811,17 +821,17 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent" , M.get_subscript (| - M.get_name (| globals, "cache" |), - M.get_name (| globals, "cache_index" |) + M.get_name (| globals, locals_stack, "cache" |), + M.get_name (| globals, locals_stack, "cache_index" |) |) |) in let _ := M.assign_local (| "mix_integers" , M.call (| - M.get_name (| globals, "fnv_hash" |), + M.get_name (| globals, locals_stack, "fnv_hash" |), make_list [ - M.get_name (| globals, "mix_integers" |); - M.get_name (| globals, "parent" |) + M.get_name (| globals, locals_stack, "mix_integers" |); + M.get_name (| globals, locals_stack, "parent" |) ], make_dict [] |) @@ -835,12 +845,12 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := let _ := M.assign_local (| "mix" , M.call (| - M.get_name (| globals, "Hash64" |), + M.get_name (| globals, locals_stack, "Hash64" |), make_list [ M.call (| - M.get_name (| globals, "le_uint32_sequence_to_bytes" |), + M.get_name (| globals, locals_stack, "le_uint32_sequence_to_bytes" |), make_list [ - M.get_name (| globals, "mix_integers" |) + M.get_name (| globals, locals_stack, "mix_integers" |) ], make_dict [] |) @@ -850,9 +860,9 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak512" |), + M.get_name (| globals, locals_stack, "keccak512" |), make_list [ - M.get_name (| globals, "mix" |) + M.get_name (| globals, locals_stack, "mix" |) ], make_dict [] |) @@ -860,8 +870,9 @@ Definition generate_dataset_item : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition generate_dataset : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate the full dataset for the block identified by `block_number`. @@ -872,7 +883,7 @@ Definition generate_dataset : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ Constant.str "(* At expr: unsupported node type: GeneratorExp *)" ], @@ -882,8 +893,9 @@ Definition generate_dataset : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hashimoto : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header_hash"; "nonce"; "dataset_size"; "fetch_dataset_item" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header_hash"; "nonce"; "dataset_size"; "fetch_dataset_item" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the mix digest and the final value for a header, by aggregating data from the full dataset. @@ -908,12 +920,12 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "nonce_le" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_name (| globals, "reversed" |), + M.get_name (| globals, locals_stack, "reversed" |), make_list [ - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "nonce" |) ], make_dict [] |) @@ -924,11 +936,11 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "seed_hash" , M.call (| - M.get_name (| globals, "keccak512" |), + M.get_name (| globals, locals_stack, "keccak512" |), make_list [ BinOp.add (| - M.get_name (| globals, "header_hash" |), - M.get_name (| globals, "nonce_le" |) + M.get_name (| globals, locals_stack, "header_hash" |), + M.get_name (| globals, locals_stack, "nonce_le" |) |) ], make_dict [] @@ -937,10 +949,10 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "seed_head" , M.call (| - M.get_field (| M.get_name (| globals, "U32" |), "from_le_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U32" |), "from_le_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "seed_hash" |), + M.get_name (| globals, locals_stack, "seed_hash" |), Constant.None_, Constant.int 4, Constant.None_ @@ -952,7 +964,7 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "rows" , BinOp.floor_div (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), Constant.int 128 |) |) in @@ -960,25 +972,25 @@ Definition hashimoto : Value.t -> Value.t -> M := "mix" , BinOp.mult (| M.call (| - M.get_name (| globals, "le_bytes_to_uint32_sequence" |), + M.get_name (| globals, locals_stack, "le_bytes_to_uint32_sequence" |), make_list [ - M.get_name (| globals, "seed_hash" |) + M.get_name (| globals, locals_stack, "seed_hash" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "MIX_BYTES" |), - M.get_name (| globals, "HASH_BYTES" |) + M.get_name (| globals, locals_stack, "MIX_BYTES" |), + M.get_name (| globals, locals_stack, "HASH_BYTES" |) |) |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "HASHIMOTO_ACCESSES" |) + M.get_name (| globals, locals_stack, "HASHIMOTO_ACCESSES" |) ], make_dict [] |), @@ -988,20 +1000,20 @@ Definition hashimoto : Value.t -> Value.t -> M := "parent" , BinOp.mod_ (| M.call (| - M.get_name (| globals, "fnv" |), + M.get_name (| globals, locals_stack, "fnv" |), make_list [ BinOp.bit_xor (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "seed_head" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "seed_head" |) |); M.get_subscript (| - M.get_name (| globals, "mix" |), + M.get_name (| globals, locals_stack, "mix" |), BinOp.mod_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "mix" |) + M.get_name (| globals, locals_stack, "mix" |) ], make_dict [] |) @@ -1010,18 +1022,18 @@ Definition hashimoto : Value.t -> Value.t -> M := ], make_dict [] |), - M.get_name (| globals, "rows" |) + M.get_name (| globals, locals_stack, "rows" |) |) |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "MIX_BYTES" |), - M.get_name (| globals, "HASH_BYTES" |) + M.get_name (| globals, locals_stack, "MIX_BYTES" |), + M.get_name (| globals, locals_stack, "HASH_BYTES" |) |) ], make_dict [] @@ -1031,20 +1043,20 @@ Definition hashimoto : Value.t -> Value.t -> M := BinOp.add, "new_data", M.call (| - M.get_name (| globals, "fetch_dataset_item" |), + M.get_name (| globals, locals_stack, "fetch_dataset_item" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "parent" |) + M.get_name (| globals, locals_stack, "parent" |) ], make_dict [] |) |), - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) ], make_dict [] @@ -1059,10 +1071,10 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "mix" , M.call (| - M.get_name (| globals, "fnv_hash" |), + M.get_name (| globals, locals_stack, "fnv_hash" |), make_list [ - M.get_name (| globals, "mix" |); - M.get_name (| globals, "new_data" |) + M.get_name (| globals, locals_stack, "mix" |); + M.get_name (| globals, locals_stack, "new_data" |) ], make_dict [] |) @@ -1079,15 +1091,15 @@ Definition hashimoto : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "mix" |) + M.get_name (| globals, locals_stack, "mix" |) ], make_dict [] |); @@ -1097,25 +1109,25 @@ Definition hashimoto : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compressed_mix" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compressed_mix" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "fnv" |), + M.get_name (| globals, locals_stack, "fnv" |), make_list [ M.call (| - M.get_name (| globals, "fnv" |), + M.get_name (| globals, locals_stack, "fnv" |), make_list [ M.call (| - M.get_name (| globals, "fnv" |), + M.get_name (| globals, locals_stack, "fnv" |), make_list [ M.get_subscript (| - M.get_name (| globals, "mix" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "mix" |), + M.get_name (| globals, locals_stack, "i" |) |); M.get_subscript (| - M.get_name (| globals, "mix" |), + M.get_name (| globals, locals_stack, "mix" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -1123,9 +1135,9 @@ Definition hashimoto : Value.t -> Value.t -> M := make_dict [] |); M.get_subscript (| - M.get_name (| globals, "mix" |), + M.get_name (| globals, locals_stack, "mix" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 2 |) |) @@ -1133,9 +1145,9 @@ Definition hashimoto : Value.t -> Value.t -> M := make_dict [] |); M.get_subscript (| - M.get_name (| globals, "mix" |), + M.get_name (| globals, locals_stack, "mix" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 3 |) |) @@ -1154,9 +1166,9 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "mix_digest" , M.call (| - M.get_name (| globals, "le_uint32_sequence_to_bytes" |), + M.get_name (| globals, locals_stack, "le_uint32_sequence_to_bytes" |), make_list [ - M.get_name (| globals, "compressed_mix" |) + M.get_name (| globals, locals_stack, "compressed_mix" |) ], make_dict [] |) @@ -1164,24 +1176,25 @@ Definition hashimoto : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| - M.get_name (| globals, "seed_hash" |), - M.get_name (| globals, "mix_digest" |) + M.get_name (| globals, locals_stack, "seed_hash" |), + M.get_name (| globals, locals_stack, "mix_digest" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ] |) in M.pure Constant.None_)). Definition hashimoto_light : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header_hash"; "nonce"; "cache"; "dataset_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header_hash"; "nonce"; "cache"; "dataset_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Run the [`hashimoto`] algorithm by generating dataset item using the cache instead of loading the full dataset into main memory. @@ -1207,12 +1220,12 @@ Definition hashimoto_light : Value.t -> Value.t -> M := (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "hashimoto" |), + M.get_name (| globals, locals_stack, "hashimoto" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_name (| globals, "nonce" |); - M.get_name (| globals, "dataset_size" |); - M.get_name (| globals, "fetch_dataset_item" |) + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_name (| globals, locals_stack, "nonce" |); + M.get_name (| globals, locals_stack, "dataset_size" |); + M.get_name (| globals, locals_stack, "fetch_dataset_item" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/exceptions.v b/CoqOfPython/ethereum/exceptions.v index 275bc32..4823691 100644 --- a/CoqOfPython/ethereum/exceptions.v +++ b/CoqOfPython/ethereum/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.exceptions". +Definition globals : Globals.t := "ethereum.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/fork_criteria.v b/CoqOfPython/ethereum/fork_criteria.v index b4e814f..f4745fa 100644 --- a/CoqOfPython/ethereum/fork_criteria.v +++ b/CoqOfPython/ethereum/fork_criteria.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.fork_criteria". +Definition globals : Globals.t := "ethereum.fork_criteria". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,8 +40,9 @@ Definition ForkCriteria : Value.t := [ ( "__eq__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "other" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "other" ] in + ltac:(M.monadic ( let _ := Constant.str " Equality for fork criteria. " in @@ -47,10 +50,10 @@ Definition ForkCriteria : Value.t := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "other" |); - M.get_name (| globals, "ForkCriteria" |) + M.get_name (| globals, locals_stack, "other" |); + M.get_name (| globals, locals_stack, "ForkCriteria" |) ], make_dict [] |), @@ -58,8 +61,8 @@ Definition ForkCriteria : Value.t := ltac:(M.monadic ( let _ := M.return_ (| Compare.eq (| - M.get_field (| M.get_name (| globals, "self" |), "_internal" |), - M.get_field (| M.get_name (| globals, "other" |), "_internal" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_internal" |), + M.get_field (| M.get_name (| globals, locals_stack, "other" |), "_internal" |) |) |) in M.pure Constant.None_ @@ -68,14 +71,15 @@ Definition ForkCriteria : Value.t := M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_)) ); ( "__lt__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "other" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "other" ] in + ltac:(M.monadic ( let _ := Constant.str " Ordering for fork criteria. Block number forks are before timestamp forks and scheduled forks are before unscheduled forks. @@ -84,10 +88,10 @@ Definition ForkCriteria : Value.t := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "other" |); - M.get_name (| globals, "ForkCriteria" |) + M.get_name (| globals, locals_stack, "other" |); + M.get_name (| globals, locals_stack, "ForkCriteria" |) ], make_dict [] |), @@ -95,8 +99,8 @@ Definition ForkCriteria : Value.t := ltac:(M.monadic ( let _ := M.return_ (| Compare.lt (| - M.get_field (| M.get_name (| globals, "self" |), "_internal" |), - M.get_field (| M.get_name (| globals, "other" |), "_internal" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_internal" |), + M.get_field (| M.get_name (| globals, locals_stack, "other" |), "_internal" |) |) |) in M.pure Constant.None_ @@ -105,22 +109,23 @@ Definition ForkCriteria : Value.t := M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "NotImplemented" |) + M.get_name (| globals, locals_stack, "NotImplemented" |) |) in M.pure Constant.None_)) ); ( "__hash__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " `ForkCriteria` is hashable, so it can be stored in dictionaries. " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "hash" |), + M.get_name (| globals, locals_stack, "hash" |), make_list [ - M.get_field (| M.get_name (| globals, "self" |), "_internal" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_internal" |) ], make_dict [] |) @@ -138,37 +143,40 @@ Definition ByBlockNumber : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "block_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "block_number" ] in + ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "_internal" |), - make_tuple [ M.get_field (| M.get_name (| globals, "ForkCriteria" |), "BLOCK_NUMBER" |); M.get_name (| globals, "block_number" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_internal" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "ForkCriteria" |), "BLOCK_NUMBER" |); M.get_name (| globals, locals_stack, "block_number" |) ] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "block_number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) in M.pure Constant.None_)) ); ( "check", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "block_number"; "timestamp" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "block_number"; "timestamp" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether the block number has been reached. " in let _ := M.return_ (| Compare.gt_e (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "self" |), "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "block_number" |) |) |) in M.pure Constant.None_)) ); ( "__repr__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " String representation of this object. " in @@ -188,37 +196,40 @@ Definition ByTimestamp : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "timestamp" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "timestamp" ] in + ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "_internal" |), - make_tuple [ M.get_field (| M.get_name (| globals, "ForkCriteria" |), "TIMESTAMP" |); M.get_name (| globals, "timestamp" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_internal" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "ForkCriteria" |), "TIMESTAMP" |); M.get_name (| globals, locals_stack, "timestamp" |) ] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "timestamp" |), - M.get_name (| globals, "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "timestamp" |), + M.get_name (| globals, locals_stack, "timestamp" |) |) in M.pure Constant.None_)) ); ( "check", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "block_number"; "timestamp" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "block_number"; "timestamp" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether the timestamp has been reached. " in let _ := M.return_ (| Compare.gt_e (| - M.get_name (| globals, "timestamp" |), - M.get_field (| M.get_name (| globals, "self" |), "timestamp" |) + M.get_name (| globals, locals_stack, "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "timestamp" |) |) |) in M.pure Constant.None_)) ); ( "__repr__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " String representation of this object. " in @@ -238,18 +249,20 @@ Definition Unscheduled : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "_internal" |), - make_tuple [ M.get_field (| M.get_name (| globals, "ForkCriteria" |), "UNSCHEDULED" |); Constant.int 0 ] + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "_internal" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "ForkCriteria" |), "UNSCHEDULED" |); Constant.int 0 ] |) in M.pure Constant.None_)) ); ( "check", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "block_number"; "timestamp" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "block_number"; "timestamp" ] in + ltac:(M.monadic ( let _ := Constant.str " Unscheduled forks never occur. " in @@ -260,8 +273,9 @@ Definition Unscheduled : Value.t := ); ( "__repr__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self" ] in + ltac:(M.monadic ( let _ := Constant.str " String representation of this object. " in diff --git a/CoqOfPython/ethereum/frontier/__init__.v b/CoqOfPython/ethereum/frontier/__init__.v index e30d7e8..1608569 100644 --- a/CoqOfPython/ethereum/frontier/__init__.v +++ b/CoqOfPython/ethereum/frontier/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.__init__". +Definition globals : Globals.t := "ethereum.frontier.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -12,7 +14,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/frontier/blocks.v b/CoqOfPython/ethereum/frontier/blocks.v index 69e273c..e976a96 100644 --- a/CoqOfPython/ethereum/frontier/blocks.v +++ b/CoqOfPython/ethereum/frontier/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.blocks". +Definition globals : Globals.t := "ethereum.frontier.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/frontier/bloom.v b/CoqOfPython/ethereum/frontier/bloom.v index c2d4fc3..9450670 100644 --- a/CoqOfPython/ethereum/frontier/bloom.v +++ b/CoqOfPython/ethereum/frontier/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.bloom". +Definition globals : Globals.t := "ethereum.frontier.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_frontier_fork_types_imports_Bloom : IsImported globals "ethereum.frontier.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/fork.v b/CoqOfPython/ethereum/frontier/fork.v index ca8bfdb..2468924 100644 --- a/CoqOfPython/ethereum/frontier/fork.v +++ b/CoqOfPython/ethereum/frontier/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.fork". +Definition globals : Globals.t := "ethereum.frontier.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -129,7 +131,7 @@ Axiom ethereum_frontier_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 5, @@ -153,7 +155,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -176,8 +178,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -197,13 +200,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -226,7 +230,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -237,9 +241,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -261,17 +265,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -284,13 +288,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -301,20 +305,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -339,110 +344,110 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -451,9 +456,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -462,9 +467,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -478,8 +483,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -498,95 +504,95 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -595,28 +601,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -642,26 +649,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -669,8 +676,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -688,9 +696,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -698,25 +706,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -725,41 +733,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -781,34 +790,35 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -832,13 +842,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -853,8 +863,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -895,50 +906,50 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |) ], make_dict [] |) @@ -946,18 +957,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -965,55 +976,55 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); + M.get_name (| globals, locals_stack, "tx" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1022,56 +1033,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1082,8 +1093,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1108,27 +1120,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1137,9 +1149,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1157,46 +1169,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1207,19 +1219,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1228,23 +1240,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1252,16 +1264,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1275,13 +1287,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1296,11 +1308,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1308,88 +1320,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1402,8 +1414,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1432,44 +1445,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1481,19 +1494,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1506,8 +1519,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1535,30 +1549,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1566,98 +1580,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1665,10 +1679,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1676,20 +1690,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1698,10 +1712,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1709,41 +1723,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1751,35 +1765,35 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1790,13 +1804,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1825,17 +1840,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1850,8 +1865,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1880,14 +1896,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -1895,7 +1911,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -1903,7 +1919,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -1915,11 +1931,11 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |) ], make_dict [] @@ -1928,8 +1944,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -1950,81 +1967,81 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash" |), + M.get_name (| globals, locals_stack, "signing_hash" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2034,13 +2051,13 @@ Definition recover_sender : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2055,8 +2072,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in the signature. @@ -2076,12 +2094,12 @@ Definition signing_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2092,8 +2110,9 @@ Definition signing_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2127,12 +2146,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2143,8 +2162,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2175,18 +2195,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2203,10 +2223,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2223,8 +2243,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2242,8 +2262,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2276,9 +2297,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_difficulty" |), + M.get_name (| globals, locals_stack, "parent_difficulty" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2048 ], @@ -2290,9 +2311,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "block_timestamp" |), + M.get_name (| globals, locals_stack, "block_timestamp" |), BinOp.add (| - M.get_name (| globals, "parent_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |), Constant.int 13 |) |), @@ -2301,8 +2322,8 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := let _ := M.assign_local (| "difficulty" , BinOp.add (| - M.get_name (| globals, "parent_difficulty" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |) in M.pure Constant.None_ @@ -2311,8 +2332,8 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := let _ := M.assign_local (| "difficulty" , BinOp.sub (| - M.get_name (| globals, "parent_difficulty" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |) in M.pure Constant.None_ @@ -2322,9 +2343,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.sub (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), @@ -2337,7 +2358,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2347,7 +2368,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2357,10 +2378,10 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/fork_types.v b/CoqOfPython/ethereum/frontier/fork_types.v index 1b8eb64..5da50e8 100644 --- a/CoqOfPython/ethereum/frontier/fork_types.v +++ b/CoqOfPython/ethereum/frontier/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.fork_types". +Definition globals : Globals.t := "ethereum.frontier.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/frontier/state.v b/CoqOfPython/ethereum/frontier/state.v index 4e111a2..442525b 100644 --- a/CoqOfPython/ethereum/frontier/state.v +++ b/CoqOfPython/ethereum/frontier/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.state". +Definition globals : Globals.t := "ethereum.frontier.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,28 +710,29 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -724,36 +742,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -770,19 +790,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -798,21 +819,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -824,8 +845,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -839,19 +861,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -868,19 +891,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -895,11 +919,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/frontier/transactions.v b/CoqOfPython/ethereum/frontier/transactions.v index 1c30efa..995a9a0 100644 --- a/CoqOfPython/ethereum/frontier/transactions.v +++ b/CoqOfPython/ethereum/frontier/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.transactions". +Definition globals : Globals.t := "ethereum.frontier.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/frontier/trie.v b/CoqOfPython/ethereum/frontier/trie.v index f92e8c5..a8b7741 100644 --- a/CoqOfPython/ethereum/frontier/trie.v +++ b/CoqOfPython/ethereum/frontier/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.trie". +Definition globals : Globals.t := "ethereum.frontier.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -86,10 +88,10 @@ Axiom ethereum_frontier_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -102,14 +104,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -119,28 +121,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -178,14 +180,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -209,7 +212,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -225,10 +228,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -237,13 +240,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -252,10 +255,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -264,13 +267,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -279,10 +282,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -291,9 +294,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -301,7 +304,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -318,9 +321,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -330,9 +333,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -341,16 +344,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -360,8 +363,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -371,25 +375,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -401,10 +405,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -412,13 +416,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -433,23 +437,23 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -474,8 +478,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -492,14 +497,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -510,8 +515,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -531,8 +537,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -540,14 +546,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -559,18 +565,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -590,10 +597,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -601,21 +608,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -628,11 +636,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -640,12 +648,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -653,7 +661,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -668,9 +676,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -678,8 +686,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -716,7 +725,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -727,9 +736,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -740,13 +749,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -754,15 +763,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -772,20 +781,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -803,7 +812,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -811,13 +820,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -826,15 +835,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -844,20 +853,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -875,9 +884,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -885,8 +894,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -903,14 +913,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -921,26 +931,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -948,17 +958,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -970,9 +980,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -980,8 +990,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1002,9 +1013,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1013,25 +1024,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1039,13 +1050,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1059,9 +1070,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1069,13 +1080,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1083,15 +1094,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1101,22 +1112,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1125,13 +1136,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1152,10 +1164,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1163,14 +1175,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1188,12 +1200,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1206,12 +1218,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1223,18 +1235,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1244,8 +1256,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1269,9 +1282,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1290,12 +1303,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1308,9 +1321,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1321,24 +1334,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1348,8 +1361,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1357,31 +1370,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1396,7 +1409,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1417,7 +1430,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1425,30 +1438,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1468,9 +1481,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1478,7 +1491,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1496,21 +1509,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1518,19 +1531,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1539,8 +1552,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1549,17 +1562,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1572,10 +1585,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/utils/__init__.v b/CoqOfPython/ethereum/frontier/utils/__init__.v index 0506f75..bf74735 100644 --- a/CoqOfPython/ethereum/frontier/utils/__init__.v +++ b/CoqOfPython/ethereum/frontier/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.utils.__init__". +Definition globals : Globals.t := "ethereum.frontier.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/frontier/utils/address.v b/CoqOfPython/ethereum/frontier/utils/address.v index 2fdbc8d..e45d41c 100644 --- a/CoqOfPython/ethereum/frontier/utils/address.v +++ b/CoqOfPython/ethereum/frontier/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.utils.address". +Definition globals : Globals.t := "ethereum.frontier.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,8 +40,9 @@ Axiom ethereum_frontier_fork_types_imports_Address : IsImported globals "ethereum.frontier.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -55,11 +58,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -74,8 +77,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -95,14 +99,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -114,7 +118,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -123,9 +127,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -133,9 +137,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/utils/hexadecimal.v b/CoqOfPython/ethereum/frontier/utils/hexadecimal.v index 865d427..8a7d1dc 100644 --- a/CoqOfPython/ethereum/frontier/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/frontier/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.frontier.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_frontier_fork_types_imports_Root : IsImported globals "ethereum.frontier.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/frontier/utils/message.v b/CoqOfPython/ethereum/frontier/utils/message.v index 6d47416..910cde2 100644 --- a/CoqOfPython/ethereum/frontier/utils/message.v +++ b/CoqOfPython/ethereum/frontier/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.utils.message". +Definition globals : Globals.t := "ethereum.frontier.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,8 +48,9 @@ Axiom ethereum_frontier_utils_address_imports_compute_contract_address : IsImported globals "ethereum.frontier.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -79,10 +82,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -91,20 +94,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -118,7 +121,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -127,7 +130,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -136,10 +139,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -147,19 +150,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -168,14 +171,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -186,7 +189,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -198,7 +201,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/vm/__init__.v b/CoqOfPython/ethereum/frontier/vm/__init__.v index 2c943a9..c7dd433 100644 --- a/CoqOfPython/ethereum/frontier/vm/__init__.v +++ b/CoqOfPython/ethereum/frontier/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.__init__". +Definition globals : Globals.t := "ethereum.frontier.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -88,8 +90,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -102,31 +105,32 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -139,7 +143,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/exceptions.v b/CoqOfPython/ethereum/frontier/vm/exceptions.v index f744f16..e226ebc 100644 --- a/CoqOfPython/ethereum/frontier/vm/exceptions.v +++ b/CoqOfPython/ethereum/frontier/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.exceptions". +Definition globals : Globals.t := "ethereum.frontier.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -69,22 +71,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/frontier/vm/gas.v b/CoqOfPython/ethereum/frontier/vm/gas.v index 5e3fe66..43ac4d4 100644 --- a/CoqOfPython/ethereum/frontier/vm/gas.v +++ b/CoqOfPython/ethereum/frontier/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.gas". +Definition globals : Globals.t := "ethereum.frontier.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -54,7 +56,7 @@ Axiom ethereum_frontier_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -64,7 +66,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -74,7 +76,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -84,7 +86,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -94,7 +96,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -104,7 +106,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -114,7 +116,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -124,7 +126,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -134,7 +136,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -144,7 +146,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -154,7 +156,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -164,7 +166,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -174,7 +176,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -184,7 +186,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -194,7 +196,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -204,7 +206,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -214,7 +216,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -224,7 +226,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -234,7 +236,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -244,7 +246,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -254,7 +256,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -264,7 +266,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -274,7 +276,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -284,7 +286,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -294,7 +296,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -304,7 +306,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 40 ], @@ -314,7 +316,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -324,7 +326,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -334,7 +336,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -344,7 +346,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -354,7 +356,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -364,7 +366,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -374,7 +376,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -384,7 +386,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -394,7 +396,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -404,7 +406,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -414,7 +416,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -443,8 +445,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -457,13 +460,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -474,22 +477,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -499,8 +502,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -520,9 +524,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -532,15 +536,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -549,16 +553,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -577,7 +582,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -587,7 +592,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -597,12 +602,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -612,14 +617,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -633,9 +638,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -643,20 +648,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -669,8 +674,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -684,16 +689,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -701,9 +706,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -712,13 +717,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -728,10 +733,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -739,8 +744,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "gas"; "to"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "gas"; "to"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount for executing Opcodes `CALL` and `CALLCODE`. @@ -764,17 +770,17 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -782,7 +788,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -790,13 +796,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -804,7 +810,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| @@ -812,12 +818,12 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "gas" |) |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) |) in let _ := M.assign_local (| @@ -825,26 +831,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( -M.get_name (| globals, "gas" |) +M.get_name (| globals, locals_stack, "gas" |) (* else *) )), ltac:(M.monadic ( BinOp.add (| - M.get_name (| globals, "GAS_CALL_STIPEND" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |), + M.get_name (| globals, locals_stack, "gas" |) |) )) |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ - M.get_name (| globals, "cost" |); - M.get_name (| globals, "stipend" |) + M.get_name (| globals, locals_stack, "cost" |); + M.get_name (| globals, locals_stack, "stipend" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/__init__.v b/CoqOfPython/ethereum/frontier/vm/instructions/__init__.v index b95c8d5..543b21d 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/frontier/vm/instructions/arithmetic.v index 542e2ad..e6bde37 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/bitwise.v b/CoqOfPython/ethereum/frontier/vm/instructions/bitwise.v index f568271..88a91e5 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,42 +62,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -108,9 +112,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,42 +122,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -167,9 +172,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -177,42 +182,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -226,39 +232,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -273,9 +280,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -283,18 +290,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -302,7 +309,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -310,7 +317,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -324,15 +331,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -340,16 +347,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -357,16 +364,16 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/block.v b/CoqOfPython/ethereum/frontier/vm/instructions/block.v index cbcd26a..0439581 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/block.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.block". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/comparison.v b/CoqOfPython/ethereum/frontier/vm/instructions/comparison.v index 8c59240..5b7be6f 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/control_flow.v b/CoqOfPython/ethereum/frontier/vm/instructions/control_flow.v index ce039f3..4f1d4d7 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/environment.v b/CoqOfPython/ethereum/frontier/vm/instructions/environment.v index 2ed9e35..c859e7a 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -60,8 +62,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -73,21 +76,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -96,14 +99,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -116,12 +120,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -130,42 +134,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -178,21 +183,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -201,14 +206,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -220,21 +226,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -243,14 +249,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -262,31 +269,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -300,30 +308,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -334,13 +342,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -349,14 +357,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -368,24 +377,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -397,14 +406,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -420,9 +430,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -430,9 +440,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -440,9 +450,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -451,12 +461,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -469,76 +479,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -550,24 +561,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -579,14 +590,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -602,9 +614,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -612,9 +624,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -622,9 +634,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -633,12 +645,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -651,76 +663,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -732,21 +745,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -755,14 +768,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -775,12 +789,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -789,26 +803,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -820,23 +834,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -849,12 +864,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -865,9 +880,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -875,9 +890,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -885,9 +900,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -896,12 +911,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -914,52 +929,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -967,27 +982,27 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/keccak.v b/CoqOfPython/ethereum/frontier/vm/instructions/keccak.v index 393213b..58e84e0 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/log.v b/CoqOfPython/ethereum/frontier/vm/instructions/log.v index f675d8d..937f587 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/log.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.log". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_frontier_vm_stack_imports_pop : IsImported globals "ethereum.frontier.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -66,9 +69,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -89,11 +92,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -102,9 +105,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -113,9 +116,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -128,74 +131,74 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -203,9 +206,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -213,9 +216,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -223,9 +226,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -233,9 +236,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/memory.v b/CoqOfPython/ethereum/frontier/vm/instructions/memory.v index 56c03a2..e3aea6b 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/stack.v b/CoqOfPython/ethereum/frontier/vm/instructions/stack.v index 18ec37d..2bd56d1 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_frontier_vm_memory_imports_buffer_read : IsImported globals "ethereum.frontier.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/storage.v b/CoqOfPython/ethereum/frontier/vm/instructions/storage.v index 754b34a..1fd54fb 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,8 +44,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -58,9 +61,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -69,43 +72,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -119,9 +123,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -132,9 +136,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,11 +146,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -156,12 +160,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -170,14 +174,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -186,12 +190,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -200,8 +204,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -209,26 +213,26 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/instructions/system.v b/CoqOfPython/ethereum/frontier/vm/instructions/system.v index 35a1fee..83f8c79 100644 --- a/CoqOfPython/ethereum/frontier/vm/instructions/system.v +++ b/CoqOfPython/ethereum/frontier/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.instructions.system". +Definition globals : Globals.t := "ethereum.frontier.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -74,8 +76,9 @@ Axiom ethereum_frontier_vm_stack_imports_push : IsImported globals "ethereum.frontier.vm.stack" "push". Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -88,9 +91,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,9 +101,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -108,9 +111,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,35 +121,35 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -155,23 +158,23 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -179,14 +182,14 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -199,15 +202,15 @@ Definition create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -223,10 +226,10 @@ Definition create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -235,11 +238,11 @@ Definition create : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -250,8 +253,8 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in M.pure Constant.None_ (* else *) @@ -260,29 +263,29 @@ Definition create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -297,27 +300,27 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -325,10 +328,10 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -336,23 +339,23 @@ Definition create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -365,21 +368,21 @@ Definition create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -394,14 +397,15 @@ Definition create : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -413,9 +417,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -423,9 +427,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -433,57 +437,58 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in @@ -493,24 +498,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -530,11 +535,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -542,10 +547,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -553,7 +558,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -561,10 +566,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -572,23 +577,23 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -601,19 +606,19 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -627,16 +632,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -648,14 +653,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -664,8 +669,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -677,12 +683,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -693,12 +699,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -709,9 +715,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,9 +725,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -729,9 +735,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -739,9 +745,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,9 +755,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -759,12 +765,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -773,42 +779,42 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -817,17 +823,17 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -838,25 +844,25 @@ Definition call : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -864,14 +870,15 @@ Definition call : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -883,12 +890,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -899,12 +906,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -915,9 +922,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -925,9 +932,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -935,9 +942,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -945,9 +952,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -955,26 +962,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -983,42 +990,42 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1027,17 +1034,17 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1048,25 +1055,25 @@ Definition callcode : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1074,14 +1081,15 @@ Definition callcode : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1093,12 +1101,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1108,37 +1116,37 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_ZERO" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1150,15 +1158,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1166,20 +1174,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1187,33 +1195,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1223,14 +1231,14 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in diff --git a/CoqOfPython/ethereum/frontier/vm/interpreter.v b/CoqOfPython/ethereum/frontier/vm/interpreter.v index e1d892f..e3c5c81 100644 --- a/CoqOfPython/ethereum/frontier/vm/interpreter.v +++ b/CoqOfPython/ethereum/frontier/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.interpreter". +Definition globals : Globals.t := "ethereum.frontier.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -109,7 +111,7 @@ Axiom ethereum_frontier_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -128,8 +130,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -151,9 +154,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -165,10 +168,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -176,39 +179,39 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -222,10 +225,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -238,10 +241,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -251,14 +254,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -266,7 +269,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -278,44 +281,44 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -323,8 +326,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -341,27 +345,27 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -369,31 +373,31 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -401,22 +405,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -436,13 +441,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -454,17 +459,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -472,18 +477,18 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -495,10 +500,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -506,13 +511,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -520,22 +525,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -553,14 +559,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -568,13 +574,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/memory.v b/CoqOfPython/ethereum/frontier/vm/memory.v index be21aab..b065d71 100644 --- a/CoqOfPython/ethereum/frontier/vm/memory.v +++ b/CoqOfPython/ethereum/frontier/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.memory". +Definition globals : Globals.t := "ethereum.frontier.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/__init__.v index 34b3b7b..a61e39a 100644 --- a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.frontier.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], diff --git a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ecrecover.v index 6f8de26..5f49475 100644 --- a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.frontier.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_frontier_vm_memory_imports_buffer_read : IsImported globals "ethereum.frontier.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/identity.v index ff7bb79..e032154 100644 --- a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.frontier.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_frontier_vm_gas_imports_charge_gas : IsImported globals "ethereum.frontier.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/mapping.v index f2f606e..6aec646 100644 --- a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.frontier.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ripemd160.v index 3f3bbd6..a49f853 100644 --- a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.frontier.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_frontier_vm_gas_imports_charge_gas : IsImported globals "ethereum.frontier.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/sha256.v index e72a688..b7ef0c6 100644 --- a/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/frontier/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.frontier.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_frontier_vm_gas_imports_charge_gas : IsImported globals "ethereum.frontier.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/frontier/vm/runtime.v b/CoqOfPython/ethereum/frontier/vm/runtime.v index 316e3e2..47407c6 100644 --- a/CoqOfPython/ethereum/frontier/vm/runtime.v +++ b/CoqOfPython/ethereum/frontier/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.runtime". +Definition globals : Globals.t := "ethereum.frontier.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_frontier_vm_instructions_imports_Ops : IsImported globals "ethereum.frontier.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/frontier/vm/stack.v b/CoqOfPython/ethereum/frontier/vm/stack.v index 875e1e7..8345b56 100644 --- a/CoqOfPython/ethereum/frontier/vm/stack.v +++ b/CoqOfPython/ethereum/frontier/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.frontier.vm.stack". +Definition globals : Globals.t := "ethereum.frontier.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_frontier_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.frontier.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/genesis.v b/CoqOfPython/ethereum/genesis.v index cd70564..522d754 100644 --- a/CoqOfPython/ethereum/genesis.v +++ b/CoqOfPython/ethereum/genesis.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.genesis". +Definition globals : Globals.t := "ethereum.genesis". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -62,7 +64,7 @@ Axiom ethereum_utils_hexadecimal_imports_hex_to_uint : IsImported globals "ethereum.utils.hexadecimal" "hex_to_uint". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition GenesisConfiguration : Value.t := @@ -76,8 +78,9 @@ Definition GenesisConfiguration : Value.t := ]. Definition get_genesis_configuration : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "genesis_file" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "genesis_file" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the genesis configuration from the given genesis json file. @@ -98,11 +101,11 @@ Definition get_genesis_configuration : Value.t -> Value.t -> M := "genesis_str_data" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_name (| globals, "bytes" |); + M.get_name (| globals, locals_stack, "bytes" |); M.call (| - M.get_field (| M.get_name (| globals, "pkgutil" |), "get_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "pkgutil" |), "get_data" |), make_list [ Constant.str "ethereum"; Constant.str "(* At expr: unsupported node type: JoinedStr *)" @@ -119,16 +122,16 @@ Definition get_genesis_configuration : Value.t -> Value.t -> M := let _ := M.assign_local (| "genesis_data" , M.call (| - M.get_field (| M.get_name (| globals, "json" |), "loads" |), + M.get_field (| M.get_name (| globals, locals_stack, "json" |), "loads" |), make_list [ - M.get_name (| globals, "genesis_str_data" |) + M.get_name (| globals, locals_stack, "genesis_str_data" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "GenesisConfiguration" |), + M.get_name (| globals, locals_stack, "GenesisConfiguration" |), make_list [], make_dict [] |) @@ -136,8 +139,9 @@ Definition get_genesis_configuration : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_or_base_10_str_to_u256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "balance" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "balance" ] in + ltac:(M.monadic ( let _ := Constant.str " The genesis format can have balances and timestamps as either base 10 numbers or 0x prefixed hex. This function supports both. @@ -146,7 +150,7 @@ Definition hex_or_base_10_str_to_u256 : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_field (| M.get_name (| globals, "balance" |), "startswith" |), + M.get_field (| M.get_name (| globals, locals_stack, "balance" |), "startswith" |), make_list [ Constant.str "0x" ], @@ -156,9 +160,9 @@ Definition hex_or_base_10_str_to_u256 : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "hex_to_u256" |), + M.get_name (| globals, locals_stack, "hex_to_u256" |), make_list [ - M.get_name (| globals, "balance" |) + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) @@ -168,12 +172,12 @@ Definition hex_or_base_10_str_to_u256 : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "balance" |) + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) @@ -186,8 +190,9 @@ Definition hex_or_base_10_str_to_u256 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition add_genesis_block : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hardfork"; "chain"; "genesis" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hardfork"; "chain"; "genesis" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the genesis block to an empty blockchain. @@ -234,9 +239,9 @@ Definition add_genesis_block : Value.t -> Value.t -> M := " in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "account" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "account" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "genesis" |), "initial_accounts" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "genesis" |), "initial_accounts" |), "items" |), make_list [], make_dict [] |), @@ -244,29 +249,29 @@ Definition add_genesis_block : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_field (| M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "utils" |), "hexadecimal" |), "hex_to_address" |), + M.get_field (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "utils" |), "hexadecimal" |), "hex_to_address" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "state" |), "set_account" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "state" |), "set_account" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); - M.get_name (| globals, "address" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "fork_types" |), "Account" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "fork_types" |), "Account" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "account" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "get" |), make_list [ Constant.str "nonce"; Constant.str "0" @@ -280,10 +285,10 @@ Definition add_genesis_block : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "hex_or_base_10_str_to_u256" |), + M.get_name (| globals, locals_stack, "hex_or_base_10_str_to_u256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "account" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "get" |), make_list [ Constant.str "balance"; Constant.int 0 @@ -294,10 +299,10 @@ Definition add_genesis_block : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "account" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "get" |), make_list [ Constant.str "code"; Constant.str "0x" @@ -315,10 +320,10 @@ Definition add_genesis_block : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "key" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "key" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "account" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "get" |), make_list [ Constant.str "storage"; Constant.str "(* At expr: unsupported node type: Dict *)" @@ -330,21 +335,21 @@ Definition add_genesis_block : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "state" |), "set_storage" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "state" |), "set_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); - M.get_name (| globals, "address" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "hex_to_bytes32" |), + M.get_name (| globals, locals_stack, "hex_to_bytes32" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "hex_to_uint" |), + M.get_name (| globals, locals_stack, "hex_to_uint" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -371,9 +376,9 @@ Definition add_genesis_block : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "hasattr" |), + M.get_name (| globals, locals_stack, "hasattr" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "blocks" |), "Header" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "blocks" |), "Header" |); Constant.str "mix_digest" ], make_dict [] @@ -382,11 +387,11 @@ Definition add_genesis_block : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "fields" |), + M.get_name (| globals, locals_stack, "fields" |), Constant.str "mix_digest" |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "fork_types" |), "Hash32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "fork_types" |), "Hash32" |), make_list [ BinOp.mult (| Constant.bytes "00", @@ -401,11 +406,11 @@ Definition add_genesis_block : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "fields" |), + M.get_name (| globals, locals_stack, "fields" |), Constant.str "prev_randao" |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "fork_types" |), "Hash32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "fork_types" |), "Hash32" |), make_list [ BinOp.mult (| Constant.bytes "00", @@ -421,9 +426,9 @@ Definition add_genesis_block : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "hasattr" |), + M.get_name (| globals, locals_stack, "hasattr" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "blocks" |), "Header" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "blocks" |), "Header" |); Constant.str "base_fee_per_gas" ], make_dict [] @@ -432,11 +437,11 @@ Definition add_genesis_block : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "fields" |), + M.get_name (| globals, locals_stack, "fields" |), Constant.str "base_fee_per_gas" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.pow (| Constant.int 10, @@ -454,7 +459,7 @@ Definition add_genesis_block : Value.t -> Value.t -> M := let _ := M.assign_local (| "genesis_header" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "blocks" |), "Header" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "blocks" |), "Header" |), make_list [], make_dict [] |) @@ -462,20 +467,20 @@ Definition add_genesis_block : Value.t -> Value.t -> M := let _ := M.assign_local (| "genesis_block" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "hardfork" |), "blocks" |), "Block" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "hardfork" |), "blocks" |), "Block" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "genesis_block" |) + M.get_name (| globals, locals_stack, "genesis_block" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |), - M.get_field (| M.get_name (| globals, "genesis" |), "chain_id" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |), + M.get_field (| M.get_name (| globals, locals_stack, "genesis" |), "chain_id" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/__init__.v b/CoqOfPython/ethereum/gray_glacier/__init__.v index 214f63d..81a302c 100644 --- a/CoqOfPython/ethereum/gray_glacier/__init__.v +++ b/CoqOfPython/ethereum/gray_glacier/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.__init__". +Definition globals : Globals.t := "ethereum.gray_glacier.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -13,7 +15,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 15050000 ], diff --git a/CoqOfPython/ethereum/gray_glacier/blocks.v b/CoqOfPython/ethereum/gray_glacier/blocks.v index 04f7678..2713c4f 100644 --- a/CoqOfPython/ethereum/gray_glacier/blocks.v +++ b/CoqOfPython/ethereum/gray_glacier/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.blocks". +Definition globals : Globals.t := "ethereum.gray_glacier.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/gray_glacier/bloom.v b/CoqOfPython/ethereum/gray_glacier/bloom.v index d2b450d..7e0e09e 100644 --- a/CoqOfPython/ethereum/gray_glacier/bloom.v +++ b/CoqOfPython/ethereum/gray_glacier/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.bloom". +Definition globals : Globals.t := "ethereum.gray_glacier.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_gray_glacier_fork_types_imports_Bloom : IsImported globals "ethereum.gray_glacier.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/fork.v b/CoqOfPython/ethereum/gray_glacier/fork.v index 0bd20df..d29fe9d 100644 --- a/CoqOfPython/ethereum/gray_glacier/fork.v +++ b/CoqOfPython/ethereum/gray_glacier/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.fork". +Definition globals : Globals.t := "ethereum.gray_glacier.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -150,7 +152,7 @@ Axiom ethereum_gray_glacier_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -182,7 +184,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -200,10 +202,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -225,8 +227,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -246,13 +249,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -275,7 +279,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -286,9 +290,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -310,17 +314,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -333,13 +337,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -350,20 +354,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -388,112 +393,112 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "base_fee_per_gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "base_fee_per_gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -502,9 +507,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -513,9 +518,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -529,8 +534,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the base fee per gas for the block. @@ -553,22 +559,22 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_gas_target" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "ELASTICITY_MULTIPLIER" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "ELASTICITY_MULTIPLIER" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_name (| globals, "block_gas_limit" |); - M.get_name (| globals, "parent_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |); + M.get_name (| globals, locals_stack, "parent_gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -576,14 +582,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "expected_base_fee_per_gas" , - M.get_name (| globals, "parent_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |) |) in M.pure Constant.None_ (* else *) @@ -592,40 +598,40 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |); Constant.int 1 ], @@ -635,8 +641,8 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.add (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -645,36 +651,36 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_target" |), - M.get_name (| globals, "parent_gas_used" |) + M.get_name (| globals, locals_stack, "parent_gas_target" |), + M.get_name (| globals, locals_stack, "parent_gas_used" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.sub (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -683,9 +689,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "expected_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |) ], make_dict [] |) @@ -693,8 +699,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -713,123 +720,123 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |), - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , M.call (| - M.get_name (| globals, "calculate_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "calculate_base_fee_per_gas" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "base_fee_per_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "expected_base_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -838,28 +845,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -885,27 +893,27 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |); - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -913,8 +921,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -932,9 +941,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -942,25 +951,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -969,41 +978,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -1031,23 +1041,23 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1056,46 +1066,46 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "priority_fee_per_gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) ], make_dict [] @@ -1104,38 +1114,39 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_price" , BinOp.add (| - M.get_name (| globals, "priority_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_price" , - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ] |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -1159,7 +1170,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -1168,10 +1179,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -1181,9 +1192,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1196,10 +1207,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1209,9 +1220,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1221,7 +1232,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -1240,8 +1251,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -1286,22 +1298,22 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1310,16 +1322,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1327,9 +1339,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1337,14 +1349,14 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ], M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "base_fee_per_gas" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -1352,18 +1364,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1371,49 +1383,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1422,56 +1434,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1482,8 +1494,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1508,27 +1521,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1537,9 +1550,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1557,46 +1570,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1607,19 +1620,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1628,23 +1641,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1652,16 +1665,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1675,13 +1688,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1696,11 +1709,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1708,88 +1721,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1802,8 +1815,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1832,44 +1846,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1881,19 +1895,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1906,8 +1920,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1935,30 +1950,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1967,10 +1982,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1979,8 +1994,8 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |) |) |) in M.pure Constant.None_ @@ -1989,100 +2004,100 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "max_gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "max_gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "effective_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "effective_gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2090,7 +2105,7 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2099,10 +2114,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2110,25 +2125,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -2152,14 +2167,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2167,10 +2182,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2178,20 +2193,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 5 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -2200,17 +2215,17 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "priority_fee_per_gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |), - M.get_field (| M.get_name (| globals, "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| @@ -2218,41 +2233,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_name (| globals, "priority_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -2260,31 +2275,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -2295,20 +2310,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -2321,14 +2336,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2340,27 +2355,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2376,13 +2391,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -2411,17 +2427,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -2436,8 +2452,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -2466,14 +2483,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2481,7 +2498,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2489,7 +2506,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2503,9 +2520,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2516,7 +2533,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2535,10 +2552,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2546,26 +2563,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -2581,17 +2598,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -2600,8 +2617,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2624,47 +2642,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2672,10 +2690,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2683,19 +2701,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2705,18 +2723,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2728,58 +2746,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2796,10 +2814,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2808,15 +2826,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2831,10 +2849,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2843,15 +2861,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_1559" |), + M.get_name (| globals, locals_stack, "signing_hash_1559" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2870,13 +2888,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2891,8 +2909,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2908,12 +2927,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2924,8 +2943,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2943,19 +2963,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2971,8 +2991,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -2988,14 +3009,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -3007,8 +3028,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_1559 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 1559 signature. @@ -3024,14 +3046,14 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -3043,8 +3065,9 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -3078,12 +3101,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -3094,8 +3117,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -3126,18 +3150,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3154,10 +3178,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3174,8 +3198,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -3193,8 +3217,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -3238,21 +3263,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -3262,11 +3287,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -3284,13 +3309,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -3299,13 +3324,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -3316,7 +3341,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -3326,7 +3351,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -3336,13 +3361,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/fork_types.v b/CoqOfPython/ethereum/gray_glacier/fork_types.v index b0a58e8..783edf8 100644 --- a/CoqOfPython/ethereum/gray_glacier/fork_types.v +++ b/CoqOfPython/ethereum/gray_glacier/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.fork_types". +Definition globals : Globals.t := "ethereum.gray_glacier.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/gray_glacier/state.v b/CoqOfPython/ethereum/gray_glacier/state.v index 8cde655..a514f26 100644 --- a/CoqOfPython/ethereum/gray_glacier/state.v +++ b/CoqOfPython/ethereum/gray_glacier/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.state". +Definition globals : Globals.t := "ethereum.gray_glacier.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1163,19 +1191,20 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1194,14 +1223,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,18 +1243,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1234,7 +1263,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1242,7 +1271,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1255,10 +1284,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1266,14 +1295,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/transactions.v b/CoqOfPython/ethereum/gray_glacier/transactions.v index 3fb1a1b..ac2e6ac 100644 --- a/CoqOfPython/ethereum/gray_glacier/transactions.v +++ b/CoqOfPython/ethereum/gray_glacier/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.transactions". +Definition globals : Globals.t := "ethereum.gray_glacier.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,14 +99,15 @@ Definition FeeMarketTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -112,17 +115,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -131,10 +134,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -144,9 +147,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -159,10 +162,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -172,9 +175,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -184,7 +187,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -199,8 +202,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -208,10 +212,10 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), @@ -222,7 +226,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 @@ -231,11 +235,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -252,7 +256,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 2 @@ -261,11 +265,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "FeeMarketTransaction" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -277,7 +281,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ @@ -286,7 +290,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/gray_glacier/trie.v b/CoqOfPython/ethereum/gray_glacier/trie.v index 8b795d8..a3a2fcc 100644 --- a/CoqOfPython/ethereum/gray_glacier/trie.v +++ b/CoqOfPython/ethereum/gray_glacier/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.trie". +Definition globals : Globals.t := "ethereum.gray_glacier.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_gray_glacier_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,34 +124,34 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -187,14 +189,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -218,7 +221,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -234,10 +237,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -246,13 +249,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -261,10 +264,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -273,13 +276,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -288,10 +291,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -300,9 +303,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -310,7 +313,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -327,9 +330,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -339,9 +342,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -350,16 +353,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -369,8 +372,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -380,25 +384,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -410,10 +414,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -421,13 +425,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -442,27 +446,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -486,8 +490,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -504,14 +509,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -522,8 +527,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -543,8 +549,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -552,14 +558,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -571,18 +577,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -602,10 +609,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -613,21 +620,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -640,11 +648,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -652,12 +660,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -665,7 +673,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -680,9 +688,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -690,8 +698,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -728,7 +737,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -739,9 +748,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -752,13 +761,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -766,15 +775,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -784,20 +793,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -815,7 +824,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -823,13 +832,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -838,15 +847,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -856,20 +865,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -887,9 +896,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -897,8 +906,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -915,14 +925,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -933,26 +943,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -960,17 +970,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -982,9 +992,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -992,8 +1002,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1014,9 +1025,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1025,25 +1036,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1051,13 +1062,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1071,9 +1082,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1081,13 +1092,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1095,15 +1106,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1113,22 +1124,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1137,13 +1148,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1164,10 +1176,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1175,14 +1187,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1200,12 +1212,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1218,12 +1230,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1235,18 +1247,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1256,8 +1268,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1281,9 +1294,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1302,12 +1315,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1320,9 +1333,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1333,24 +1346,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1360,8 +1373,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1369,31 +1382,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1408,7 +1421,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1429,7 +1442,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1437,30 +1450,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1480,9 +1493,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1490,7 +1503,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1508,21 +1521,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1530,19 +1543,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1551,8 +1564,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1561,17 +1574,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1584,10 +1597,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/utils/__init__.v b/CoqOfPython/ethereum/gray_glacier/utils/__init__.v index 180ce26..39b5ce6 100644 --- a/CoqOfPython/ethereum/gray_glacier/utils/__init__.v +++ b/CoqOfPython/ethereum/gray_glacier/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.utils.__init__". +Definition globals : Globals.t := "ethereum.gray_glacier.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/gray_glacier/utils/address.v b/CoqOfPython/ethereum/gray_glacier/utils/address.v index a7dbc7d..4709a6e 100644 --- a/CoqOfPython/ethereum/gray_glacier/utils/address.v +++ b/CoqOfPython/ethereum/gray_glacier/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.utils.address". +Definition globals : Globals.t := "ethereum.gray_glacier.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_gray_glacier_fork_types_imports_Address : IsImported globals "ethereum.gray_glacier.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/utils/hexadecimal.v b/CoqOfPython/ethereum/gray_glacier/utils/hexadecimal.v index 3ad2857..28d1537 100644 --- a/CoqOfPython/ethereum/gray_glacier/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/gray_glacier/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.gray_glacier.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_gray_glacier_fork_types_imports_Root : IsImported globals "ethereum.gray_glacier.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/gray_glacier/utils/message.v b/CoqOfPython/ethereum/gray_glacier/utils/message.v index c2728e8..964fc28 100644 --- a/CoqOfPython/ethereum/gray_glacier/utils/message.v +++ b/CoqOfPython/ethereum/gray_glacier/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.utils.message". +Definition globals : Globals.t := "ethereum.gray_glacier.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_gray_glacier_utils_address_imports_compute_contract_address : IsImported globals "ethereum.gray_glacier.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/__init__.v b/CoqOfPython/ethereum/gray_glacier/vm/__init__.v index 085ff3e..f29ae97 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/__init__.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.__init__". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,8 +99,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -111,30 +114,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -142,19 +145,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,24 +167,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -196,15 +200,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -217,8 +221,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -226,19 +230,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -254,7 +258,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/exceptions.v b/CoqOfPython/ethereum/gray_glacier/vm/exceptions.v index 3eab002..9455938 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/exceptions.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.exceptions". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/gas.v b/CoqOfPython/ethereum/gray_glacier/vm/gas.v index a6dcb12..c641090 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/gas.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.gas". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_gray_glacier_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -86,7 +88,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 4800 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -116,7 +118,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -126,7 +128,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -136,7 +138,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -166,7 +168,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -176,7 +178,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -196,7 +198,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -206,7 +208,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -216,7 +218,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -226,7 +228,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -236,7 +238,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -246,7 +248,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -256,7 +258,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -266,7 +268,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -276,7 +278,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -286,7 +288,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -296,7 +298,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -306,7 +308,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -326,7 +328,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -336,7 +338,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -346,7 +348,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -356,7 +358,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -366,7 +368,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -376,7 +378,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -386,7 +388,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -396,7 +398,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -406,7 +408,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -416,7 +418,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -426,7 +428,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -436,7 +438,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -465,8 +467,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -479,13 +482,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -496,22 +499,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -521,8 +524,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -542,9 +546,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -554,15 +558,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -571,16 +575,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,12 +624,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -634,14 +639,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -655,9 +660,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -665,20 +670,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -691,8 +696,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -706,16 +711,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -723,9 +728,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -734,13 +739,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -750,10 +755,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -761,8 +766,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -793,13 +799,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -807,32 +813,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -846,18 +852,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -868,15 +874,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -885,8 +891,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -902,9 +909,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/__init__.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/__init__.v index a505398..aec2c0b 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/arithmetic.v index d4d5eed..6362212 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/bitwise.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/bitwise.v index c580c05..dc375db 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/block.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/block.v index 1b25dc5..b511399 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/block.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.block". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,14 +350,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -361,21 +370,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -384,7 +393,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/comparison.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/comparison.v index 64165db..c003eff 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/control_flow.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/control_flow.v index 0438b4c..5c7b1a5 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/environment.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/environment.v index 13a017d..3bb0ad5 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -149,16 +153,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -166,17 +170,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -185,32 +189,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -223,21 +228,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -246,14 +251,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -265,21 +271,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -288,14 +294,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -307,31 +314,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -345,30 +353,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -379,13 +387,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -394,14 +402,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -413,24 +422,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -442,14 +451,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -465,9 +475,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -475,9 +485,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -485,9 +495,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -496,12 +506,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -514,76 +524,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -595,24 +606,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -624,14 +635,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -647,9 +659,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -657,9 +669,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -667,9 +679,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,12 +690,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -696,76 +708,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -777,21 +790,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -800,14 +813,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -820,12 +834,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -837,16 +851,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -854,17 +868,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -873,16 +887,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -894,23 +908,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -923,12 +938,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -939,9 +954,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -949,9 +964,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -959,9 +974,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -970,12 +985,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -988,18 +1003,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1009,21 +1024,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1032,22 +1047,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1056,19 +1071,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1076,34 +1091,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1114,24 +1130,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1143,14 +1159,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1162,9 +1179,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1172,9 +1189,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1182,9 +1199,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1193,12 +1210,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1211,108 +1228,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1323,12 +1341,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1340,16 +1358,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1357,17 +1375,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1376,10 +1394,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1388,15 +1406,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1409,12 +1427,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1425,23 +1443,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1453,42 +1472,43 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the base fee of the current block on to the stack. @@ -1500,21 +1520,21 @@ Definition base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "base_fee_per_gas" |) ], make_dict [] |) @@ -1523,7 +1543,7 @@ Definition base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/keccak.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/keccak.v index a82edc7..ea84567 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/log.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/log.v index 6e41a53..971c211 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/log.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.log". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_pop : IsImported globals "ethereum.gray_glacier.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/memory.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/memory.v index 1516f1c..1f20979 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/stack.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/stack.v index c680a10..5afb343 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_gray_glacier_vm_memory_imports_buffer_read : IsImported globals "ethereum.gray_glacier.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/storage.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/storage.v index 81cda0d..d897e28 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -59,8 +61,9 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -75,9 +78,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -89,16 +92,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -106,17 +109,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -125,33 +128,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -165,9 +169,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -178,32 +182,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -211,11 +215,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -223,7 +227,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -234,22 +238,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -261,13 +265,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -277,7 +281,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -285,7 +289,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -294,8 +298,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -306,7 +310,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -314,8 +318,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -324,18 +328,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -346,11 +350,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -365,12 +369,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -379,11 +383,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -397,8 +401,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -406,20 +410,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -430,16 +434,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -458,34 +462,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/instructions/system.v b/CoqOfPython/ethereum/gray_glacier/vm/instructions/system.v index 0bd77ce..016e5bb 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/instructions/system.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.instructions.system". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,28 +107,29 @@ Axiom ethereum_gray_glacier_vm_stack_imports_push : IsImported globals "ethereum.gray_glacier.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -136,32 +139,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -171,15 +174,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -195,10 +198,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -208,15 +211,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -237,29 +240,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -279,27 +282,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -307,10 +310,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -318,27 +321,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,25 +354,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -381,8 +384,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -394,9 +398,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -404,9 +408,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -414,9 +418,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -424,46 +428,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -472,26 +476,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -506,9 +511,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -516,9 +521,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -526,9 +531,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -537,9 +542,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -550,11 +555,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -564,12 +569,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -580,43 +585,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -625,26 +630,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -656,9 +662,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -666,9 +672,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -676,63 +682,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -740,24 +747,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -777,11 +784,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -789,10 +796,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -800,7 +807,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -808,10 +815,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -819,27 +826,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -852,23 +859,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -882,16 +889,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -903,14 +910,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -919,8 +926,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -932,12 +940,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -948,12 +956,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -964,9 +972,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -974,9 +982,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -984,9 +992,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -994,9 +1002,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1004,9 +1012,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1014,12 +1022,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1029,28 +1037,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1060,16 +1068,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1077,7 +1085,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1085,7 +1093,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1093,13 +1101,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1107,56 +1115,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1165,25 +1173,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1192,17 +1200,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1212,32 +1220,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1245,14 +1253,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1264,12 +1273,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,12 +1289,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1296,9 +1305,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,9 +1315,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1316,9 +1325,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1326,9 +1335,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1336,26 +1345,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1365,28 +1374,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1395,13 +1404,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1409,58 +1418,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1469,17 +1478,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1489,32 +1498,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1522,14 +1531,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1541,12 +1551,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1556,28 +1566,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1589,20 +1599,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1615,7 +1625,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1623,32 +1633,32 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1656,33 +1666,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1692,9 +1702,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1702,19 +1712,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1724,15 +1734,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1744,12 +1755,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1760,12 +1771,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,9 +1787,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1786,9 +1797,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1796,9 +1807,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1806,9 +1817,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1816,12 +1827,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1831,104 +1842,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1940,12 +1952,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1956,12 +1968,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1972,9 +1984,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1982,9 +1994,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1992,9 +2004,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2002,9 +2014,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2012,12 +2024,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2027,110 +2039,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2142,9 +2155,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2152,9 +2165,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2162,54 +2175,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/interpreter.v b/CoqOfPython/ethereum/gray_glacier/vm/interpreter.v index af521c5..1aa54db 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/interpreter.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.interpreter". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -126,7 +128,7 @@ Axiom ethereum_gray_glacier_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -149,8 +151,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -172,9 +175,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -186,10 +189,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -197,44 +200,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -248,10 +251,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -264,10 +267,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -276,13 +279,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -292,12 +295,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -314,14 +317,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -329,7 +332,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -337,7 +340,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -349,22 +352,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -374,29 +377,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -404,8 +407,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -422,43 +426,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -466,24 +470,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -491,22 +495,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -526,13 +531,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -544,17 +549,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -562,10 +567,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -573,12 +578,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -590,10 +595,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -601,13 +606,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -615,22 +620,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -648,14 +654,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -663,13 +669,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/memory.v b/CoqOfPython/ethereum/gray_glacier/vm/memory.v index 3aa8c8a..c3869cf 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/memory.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.memory". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/__init__.v index fd5c1ed..6fbdf68 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/alt_bn128.v index 35d4975..a2214fe 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_gray_glacier_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.gray_glacier.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/blake2f.v index febbff6..c52e464 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_gray_glacier_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.gray_glacier.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ecrecover.v index 2df1000..ed99d82 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_gray_glacier_vm_memory_imports_buffer_read : IsImported globals "ethereum.gray_glacier.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/identity.v index e41c6b5..52e89a2 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_gray_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.gray_glacier.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/mapping.v index 61078a7..54b515b 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/modexp.v index a12f219..49c54b1 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ripemd160.v index 553c4c2..9e6da29 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_gray_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.gray_glacier.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/sha256.v index ae4e91d..85a0889 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_gray_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.gray_glacier.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/gray_glacier/vm/runtime.v b/CoqOfPython/ethereum/gray_glacier/vm/runtime.v index 4c10884..9bcce8b 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/runtime.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.runtime". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_gray_glacier_vm_instructions_imports_Ops : IsImported globals "ethereum.gray_glacier.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/gray_glacier/vm/stack.v b/CoqOfPython/ethereum/gray_glacier/vm/stack.v index 4742c55..eb37711 100644 --- a/CoqOfPython/ethereum/gray_glacier/vm/stack.v +++ b/CoqOfPython/ethereum/gray_glacier/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.gray_glacier.vm.stack". +Definition globals : Globals.t := "ethereum.gray_glacier.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_gray_glacier_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.gray_glacier.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/__init__.v b/CoqOfPython/ethereum/homestead/__init__.v index b8b69f5..362e5ec 100644 --- a/CoqOfPython/ethereum/homestead/__init__.v +++ b/CoqOfPython/ethereum/homestead/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.__init__". +Definition globals : Globals.t := "ethereum.homestead.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -15,7 +17,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 1150000 ], diff --git a/CoqOfPython/ethereum/homestead/blocks.v b/CoqOfPython/ethereum/homestead/blocks.v index 237a920..a91ad83 100644 --- a/CoqOfPython/ethereum/homestead/blocks.v +++ b/CoqOfPython/ethereum/homestead/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.blocks". +Definition globals : Globals.t := "ethereum.homestead.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/homestead/bloom.v b/CoqOfPython/ethereum/homestead/bloom.v index 04c7450..251dad4 100644 --- a/CoqOfPython/ethereum/homestead/bloom.v +++ b/CoqOfPython/ethereum/homestead/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.bloom". +Definition globals : Globals.t := "ethereum.homestead.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_homestead_fork_types_imports_Bloom : IsImported globals "ethereum.homestead.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/fork.v b/CoqOfPython/ethereum/homestead/fork.v index 44f0c2f..d156e8e 100644 --- a/CoqOfPython/ethereum/homestead/fork.v +++ b/CoqOfPython/ethereum/homestead/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.fork". +Definition globals : Globals.t := "ethereum.homestead.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -134,7 +136,7 @@ Axiom ethereum_homestead_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 5, @@ -158,7 +160,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -181,8 +183,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -202,13 +205,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -231,7 +235,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -242,9 +246,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -266,17 +270,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -289,13 +293,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -306,20 +310,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -344,110 +349,110 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -456,9 +461,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -467,9 +472,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -483,8 +488,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -503,95 +509,95 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -600,28 +606,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -647,26 +654,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -674,8 +681,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -693,9 +701,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -703,25 +711,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -730,41 +738,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -786,34 +795,35 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -837,13 +847,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -858,8 +868,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -900,50 +911,50 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |) ], make_dict [] |) @@ -951,18 +962,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -970,55 +981,55 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); + M.get_name (| globals, locals_stack, "tx" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1027,56 +1038,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1087,8 +1098,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1113,27 +1125,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1142,9 +1154,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1162,46 +1174,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1212,19 +1224,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1233,23 +1245,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1257,16 +1269,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1280,13 +1292,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1301,11 +1313,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1313,88 +1325,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1407,8 +1419,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1437,44 +1450,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1486,19 +1499,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1511,8 +1524,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1540,30 +1554,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1571,98 +1585,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1670,10 +1684,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1681,20 +1695,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1703,10 +1717,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1714,41 +1728,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1756,35 +1770,35 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1795,13 +1809,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1830,17 +1845,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1855,8 +1870,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1885,14 +1901,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -1900,7 +1916,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -1908,7 +1924,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -1922,9 +1938,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -1935,7 +1951,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -1948,14 +1964,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -1964,8 +1980,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -1986,84 +2003,84 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash" |), + M.get_name (| globals, locals_stack, "signing_hash" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2073,13 +2090,13 @@ Definition recover_sender : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2094,8 +2111,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in the signature. @@ -2115,12 +2133,12 @@ Definition signing_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2131,8 +2149,9 @@ Definition signing_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2166,12 +2185,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2182,8 +2201,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2214,18 +2234,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2242,10 +2262,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2262,8 +2282,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2281,8 +2301,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2324,26 +2345,26 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| Constant.int 1, BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2361,13 +2382,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2375,9 +2396,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.sub (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), @@ -2390,7 +2411,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2400,7 +2421,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2410,13 +2431,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/fork_types.v b/CoqOfPython/ethereum/homestead/fork_types.v index b6ac107..acb8202 100644 --- a/CoqOfPython/ethereum/homestead/fork_types.v +++ b/CoqOfPython/ethereum/homestead/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.fork_types". +Definition globals : Globals.t := "ethereum.homestead.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/homestead/state.v b/CoqOfPython/ethereum/homestead/state.v index 139e07b..3fa3723 100644 --- a/CoqOfPython/ethereum/homestead/state.v +++ b/CoqOfPython/ethereum/homestead/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.state". +Definition globals : Globals.t := "ethereum.homestead.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,28 +710,29 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -724,36 +742,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -770,19 +790,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -798,21 +819,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -824,8 +845,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -839,19 +861,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -868,19 +891,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -895,11 +919,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/homestead/transactions.v b/CoqOfPython/ethereum/homestead/transactions.v index 18720ce..c51a67c 100644 --- a/CoqOfPython/ethereum/homestead/transactions.v +++ b/CoqOfPython/ethereum/homestead/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.transactions". +Definition globals : Globals.t := "ethereum.homestead.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/homestead/trie.v b/CoqOfPython/ethereum/homestead/trie.v index 62f57c9..60e2f90 100644 --- a/CoqOfPython/ethereum/homestead/trie.v +++ b/CoqOfPython/ethereum/homestead/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.trie". +Definition globals : Globals.t := "ethereum.homestead.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_homestead_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/utils/__init__.v b/CoqOfPython/ethereum/homestead/utils/__init__.v index c70cb4e..3847a10 100644 --- a/CoqOfPython/ethereum/homestead/utils/__init__.v +++ b/CoqOfPython/ethereum/homestead/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.utils.__init__". +Definition globals : Globals.t := "ethereum.homestead.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/homestead/utils/address.v b/CoqOfPython/ethereum/homestead/utils/address.v index 82ad5d5..9acdf08 100644 --- a/CoqOfPython/ethereum/homestead/utils/address.v +++ b/CoqOfPython/ethereum/homestead/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.utils.address". +Definition globals : Globals.t := "ethereum.homestead.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,8 +40,9 @@ Axiom ethereum_homestead_fork_types_imports_Address : IsImported globals "ethereum.homestead.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -55,11 +58,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -74,8 +77,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -95,14 +99,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -114,7 +118,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -123,9 +127,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -133,9 +137,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/utils/hexadecimal.v b/CoqOfPython/ethereum/homestead/utils/hexadecimal.v index 83917ff..2b34614 100644 --- a/CoqOfPython/ethereum/homestead/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/homestead/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.homestead.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_homestead_fork_types_imports_Root : IsImported globals "ethereum.homestead.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/homestead/utils/message.v b/CoqOfPython/ethereum/homestead/utils/message.v index 9f53490..08c3b9b 100644 --- a/CoqOfPython/ethereum/homestead/utils/message.v +++ b/CoqOfPython/ethereum/homestead/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.utils.message". +Definition globals : Globals.t := "ethereum.homestead.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,8 +48,9 @@ Axiom ethereum_homestead_utils_address_imports_compute_contract_address : IsImported globals "ethereum.homestead.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -81,10 +84,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -93,20 +96,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -120,7 +123,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -129,7 +132,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -138,10 +141,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -149,19 +152,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -170,14 +173,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -188,7 +191,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -200,7 +203,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/vm/__init__.v b/CoqOfPython/ethereum/homestead/vm/__init__.v index 3653dc8..4199afd 100644 --- a/CoqOfPython/ethereum/homestead/vm/__init__.v +++ b/CoqOfPython/ethereum/homestead/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.__init__". +Definition globals : Globals.t := "ethereum.homestead.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -88,8 +90,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -102,31 +105,32 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -139,7 +143,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/exceptions.v b/CoqOfPython/ethereum/homestead/vm/exceptions.v index 3c7fd2e..5a0a5b0 100644 --- a/CoqOfPython/ethereum/homestead/vm/exceptions.v +++ b/CoqOfPython/ethereum/homestead/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.exceptions". +Definition globals : Globals.t := "ethereum.homestead.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -69,22 +71,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/homestead/vm/gas.v b/CoqOfPython/ethereum/homestead/vm/gas.v index db0a564..b99150c 100644 --- a/CoqOfPython/ethereum/homestead/vm/gas.v +++ b/CoqOfPython/ethereum/homestead/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.gas". +Definition globals : Globals.t := "ethereum.homestead.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -54,7 +56,7 @@ Axiom ethereum_homestead_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -64,7 +66,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -74,7 +76,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -84,7 +86,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -94,7 +96,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -104,7 +106,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -114,7 +116,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -124,7 +126,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -134,7 +136,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -144,7 +146,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -154,7 +156,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -164,7 +166,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -174,7 +176,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -184,7 +186,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -194,7 +196,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -204,7 +206,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -214,7 +216,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -224,7 +226,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -234,7 +236,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -244,7 +246,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -254,7 +256,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -264,7 +266,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -274,7 +276,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -284,7 +286,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -294,7 +296,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -304,7 +306,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 40 ], @@ -314,7 +316,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -324,7 +326,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -334,7 +336,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -344,7 +346,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -354,7 +356,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -364,7 +366,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -374,7 +376,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -384,7 +386,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -394,7 +396,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -404,7 +406,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -414,7 +416,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -443,8 +445,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -457,13 +460,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -474,22 +477,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -499,8 +502,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -520,9 +524,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -532,15 +536,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -549,16 +553,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -577,7 +582,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -587,7 +592,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -597,12 +602,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -612,14 +617,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -633,9 +638,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -643,20 +648,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -669,8 +674,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -684,16 +689,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -701,9 +706,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -712,13 +717,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -728,10 +733,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -739,8 +744,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "gas"; "to"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "gas"; "to"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount for executing Opcodes `CALL` and `CALLCODE`. @@ -764,17 +770,17 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -782,7 +788,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -790,13 +796,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -804,7 +810,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| @@ -812,12 +818,12 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "gas" |) |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) |) in let _ := M.assign_local (| @@ -825,26 +831,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( -M.get_name (| globals, "gas" |) +M.get_name (| globals, locals_stack, "gas" |) (* else *) )), ltac:(M.monadic ( BinOp.add (| - M.get_name (| globals, "GAS_CALL_STIPEND" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |), + M.get_name (| globals, locals_stack, "gas" |) |) )) |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ - M.get_name (| globals, "cost" |); - M.get_name (| globals, "stipend" |) + M.get_name (| globals, locals_stack, "cost" |); + M.get_name (| globals, locals_stack, "stipend" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/__init__.v b/CoqOfPython/ethereum/homestead/vm/instructions/__init__.v index 7a70aef..258a081 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/homestead/vm/instructions/arithmetic.v index 1c889a2..ae67ed4 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/bitwise.v b/CoqOfPython/ethereum/homestead/vm/instructions/bitwise.v index 9a886dd..9e98ba0 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,42 +62,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -108,9 +112,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,42 +122,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -167,9 +172,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -177,42 +182,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -226,39 +232,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -273,9 +280,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -283,18 +290,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -302,7 +309,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -310,7 +317,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -324,15 +331,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -340,16 +347,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -357,16 +364,16 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/block.v b/CoqOfPython/ethereum/homestead/vm/instructions/block.v index b5d16dd..b6515f4 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/block.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.block". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/comparison.v b/CoqOfPython/ethereum/homestead/vm/instructions/comparison.v index dae8d81..927a6e9 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/control_flow.v b/CoqOfPython/ethereum/homestead/vm/instructions/control_flow.v index 80e73c8..836cb75 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/environment.v b/CoqOfPython/ethereum/homestead/vm/instructions/environment.v index d7f3281..54bf6fe 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -60,8 +62,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -73,21 +76,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -96,14 +99,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -116,12 +120,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -130,42 +134,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -178,21 +183,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -201,14 +206,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -220,21 +226,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -243,14 +249,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -262,31 +269,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -300,30 +308,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -334,13 +342,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -349,14 +357,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -368,24 +377,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -397,14 +406,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -420,9 +430,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -430,9 +440,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -440,9 +450,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -451,12 +461,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -469,76 +479,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -550,24 +561,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -579,14 +590,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -602,9 +614,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -612,9 +624,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -622,9 +634,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -633,12 +645,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -651,76 +663,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -732,21 +745,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -755,14 +768,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -775,12 +789,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -789,26 +803,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -820,23 +834,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -849,12 +864,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -865,9 +880,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -875,9 +890,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -885,9 +900,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -896,12 +911,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -914,52 +929,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -967,27 +982,27 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/keccak.v b/CoqOfPython/ethereum/homestead/vm/instructions/keccak.v index 6e22190..635558c 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/log.v b/CoqOfPython/ethereum/homestead/vm/instructions/log.v index 7780f07..aed85db 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/log.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.log". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_homestead_vm_stack_imports_pop : IsImported globals "ethereum.homestead.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -66,9 +69,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -89,11 +92,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -102,9 +105,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -113,9 +116,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -128,74 +131,74 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -203,9 +206,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -213,9 +216,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -223,9 +226,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -233,9 +236,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/memory.v b/CoqOfPython/ethereum/homestead/vm/instructions/memory.v index e8029f0..7724229 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/stack.v b/CoqOfPython/ethereum/homestead/vm/instructions/stack.v index dbfa9fb..59c7c5f 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_homestead_vm_memory_imports_buffer_read : IsImported globals "ethereum.homestead.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/storage.v b/CoqOfPython/ethereum/homestead/vm/instructions/storage.v index aa3f335..28827a1 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,8 +44,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -58,9 +61,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -69,43 +72,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -119,9 +123,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -132,9 +136,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,11 +146,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -156,12 +160,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -170,14 +174,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -186,12 +190,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -200,8 +204,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -209,26 +213,26 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/instructions/system.v b/CoqOfPython/ethereum/homestead/vm/instructions/system.v index 924bdf2..6bf54d2 100644 --- a/CoqOfPython/ethereum/homestead/vm/instructions/system.v +++ b/CoqOfPython/ethereum/homestead/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.instructions.system". +Definition globals : Globals.t := "ethereum.homestead.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_homestead_vm_stack_imports_push : IsImported globals "ethereum.homestead.vm.stack" "push". Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -90,9 +93,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -100,9 +103,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -110,9 +113,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,35 +123,35 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -157,23 +160,23 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -181,14 +184,14 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -201,15 +204,15 @@ Definition create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -225,10 +228,10 @@ Definition create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -237,11 +240,11 @@ Definition create : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -252,8 +255,8 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in M.pure Constant.None_ (* else *) @@ -262,29 +265,29 @@ Definition create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -299,27 +302,27 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -327,10 +330,10 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -338,23 +341,23 @@ Definition create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -367,21 +370,21 @@ Definition create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -396,14 +399,15 @@ Definition create : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -415,9 +419,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -425,9 +429,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -435,57 +439,58 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in @@ -495,24 +500,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -532,11 +537,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -544,10 +549,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -555,7 +560,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -563,10 +568,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -574,23 +579,23 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -603,19 +608,19 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -629,16 +634,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -650,14 +655,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -666,8 +671,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -679,12 +685,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -695,12 +701,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -711,9 +717,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -721,9 +727,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -731,9 +737,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -741,9 +747,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -751,9 +757,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -761,12 +767,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -775,42 +781,42 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -819,17 +825,17 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -840,26 +846,26 @@ Definition call : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -867,14 +873,15 @@ Definition call : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -886,12 +893,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -902,12 +909,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -918,9 +925,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -928,9 +935,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -938,9 +945,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -948,9 +955,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -958,26 +965,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -986,42 +993,42 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1030,17 +1037,17 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1051,26 +1058,26 @@ Definition callcode : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1078,14 +1085,15 @@ Definition callcode : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1097,12 +1105,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1112,37 +1120,37 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_ZERO" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1154,15 +1162,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1170,20 +1178,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1191,33 +1199,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1227,22 +1235,23 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1254,12 +1263,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1270,12 +1279,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1286,9 +1295,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1296,9 +1305,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,9 +1315,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1316,9 +1325,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1326,59 +1335,59 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "gas" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "gas" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/interpreter.v b/CoqOfPython/ethereum/homestead/vm/interpreter.v index e60282d..9f1e4f6 100644 --- a/CoqOfPython/ethereum/homestead/vm/interpreter.v +++ b/CoqOfPython/ethereum/homestead/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.interpreter". +Definition globals : Globals.t := "ethereum.homestead.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -109,7 +111,7 @@ Axiom ethereum_homestead_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -128,8 +130,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -151,9 +154,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -165,10 +168,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -176,39 +179,39 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -222,10 +225,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -238,10 +241,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -251,14 +254,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -266,7 +269,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -278,44 +281,44 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -323,8 +326,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -341,27 +345,27 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -369,24 +373,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -394,22 +398,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -429,13 +434,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -447,17 +452,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -465,10 +470,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -476,12 +481,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -493,10 +498,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -504,13 +509,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -518,22 +523,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -551,14 +557,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -566,13 +572,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/memory.v b/CoqOfPython/ethereum/homestead/vm/memory.v index e10df21..a6a5e4e 100644 --- a/CoqOfPython/ethereum/homestead/vm/memory.v +++ b/CoqOfPython/ethereum/homestead/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.memory". +Definition globals : Globals.t := "ethereum.homestead.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/__init__.v index f7f7382..97692d3 100644 --- a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.homestead.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], diff --git a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ecrecover.v index e4781ca..d702154 100644 --- a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.homestead.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_homestead_vm_memory_imports_buffer_read : IsImported globals "ethereum.homestead.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/identity.v index 1f02089..afb4248 100644 --- a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.homestead.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_homestead_vm_gas_imports_charge_gas : IsImported globals "ethereum.homestead.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/mapping.v index 317a774..ce1afde 100644 --- a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.homestead.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ripemd160.v index 659b238..051f03f 100644 --- a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.homestead.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_homestead_vm_gas_imports_charge_gas : IsImported globals "ethereum.homestead.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/sha256.v index e8dbb14..992b73b 100644 --- a/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/homestead/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.homestead.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_homestead_vm_gas_imports_charge_gas : IsImported globals "ethereum.homestead.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/homestead/vm/runtime.v b/CoqOfPython/ethereum/homestead/vm/runtime.v index d8d8829..fc59d58 100644 --- a/CoqOfPython/ethereum/homestead/vm/runtime.v +++ b/CoqOfPython/ethereum/homestead/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.runtime". +Definition globals : Globals.t := "ethereum.homestead.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_homestead_vm_instructions_imports_Ops : IsImported globals "ethereum.homestead.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/homestead/vm/stack.v b/CoqOfPython/ethereum/homestead/vm/stack.v index e8c3493..d6366fc 100644 --- a/CoqOfPython/ethereum/homestead/vm/stack.v +++ b/CoqOfPython/ethereum/homestead/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.homestead.vm.stack". +Definition globals : Globals.t := "ethereum.homestead.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_homestead_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.homestead.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/__init__.v b/CoqOfPython/ethereum/istanbul/__init__.v index 41dba6f..45c02fa 100644 --- a/CoqOfPython/ethereum/istanbul/__init__.v +++ b/CoqOfPython/ethereum/istanbul/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.__init__". +Definition globals : Globals.t := "ethereum.istanbul.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -14,7 +16,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 9069000 ], diff --git a/CoqOfPython/ethereum/istanbul/blocks.v b/CoqOfPython/ethereum/istanbul/blocks.v index 09c7599..50a1dcb 100644 --- a/CoqOfPython/ethereum/istanbul/blocks.v +++ b/CoqOfPython/ethereum/istanbul/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.blocks". +Definition globals : Globals.t := "ethereum.istanbul.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/istanbul/bloom.v b/CoqOfPython/ethereum/istanbul/bloom.v index 9f67f06..0093baa 100644 --- a/CoqOfPython/ethereum/istanbul/bloom.v +++ b/CoqOfPython/ethereum/istanbul/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.bloom". +Definition globals : Globals.t := "ethereum.istanbul.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_istanbul_fork_types_imports_Bloom : IsImported globals "ethereum.istanbul.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/fork.v b/CoqOfPython/ethereum/istanbul/fork.v index ce58ae7..3090be9 100644 --- a/CoqOfPython/ethereum/istanbul/fork.v +++ b/CoqOfPython/ethereum/istanbul/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.fork". +Definition globals : Globals.t := "ethereum.istanbul.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -134,7 +136,7 @@ Axiom ethereum_istanbul_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -158,7 +160,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -176,10 +178,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -201,8 +203,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -222,13 +225,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -251,7 +255,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -262,9 +266,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -286,17 +290,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -309,13 +313,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -326,20 +330,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -364,111 +369,111 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -477,9 +482,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -488,9 +493,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -504,8 +509,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -526,101 +532,101 @@ Definition validate_header : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -629,28 +635,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -676,26 +683,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -703,8 +710,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -722,9 +730,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -732,25 +740,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -759,41 +767,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -817,35 +826,36 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -869,13 +879,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -890,8 +900,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -934,51 +945,51 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -986,18 +997,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1005,49 +1016,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1056,56 +1067,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1116,8 +1127,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1142,27 +1154,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1171,9 +1183,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1191,46 +1203,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1241,19 +1253,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1262,23 +1274,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1286,16 +1298,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1309,13 +1321,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1330,11 +1342,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1342,88 +1354,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1436,8 +1448,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1466,44 +1479,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1515,19 +1528,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1540,8 +1553,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1569,30 +1583,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1600,98 +1614,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1699,10 +1713,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1710,20 +1724,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1732,10 +1746,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1743,41 +1757,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1785,31 +1799,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1820,20 +1834,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1846,14 +1860,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1865,27 +1879,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1901,13 +1915,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1936,17 +1951,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1961,8 +1976,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1991,14 +2007,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2006,7 +2022,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2014,7 +2030,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2028,9 +2044,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2041,7 +2057,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2054,14 +2070,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -2070,8 +2086,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2094,47 +2111,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2143,12 +2160,12 @@ Definition recover_sender : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2158,18 +2175,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2181,58 +2198,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2244,13 +2261,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2265,8 +2282,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2282,12 +2300,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2298,8 +2316,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2317,19 +2336,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2345,8 +2364,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2380,12 +2400,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2396,8 +2416,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2428,18 +2449,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2456,10 +2477,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2476,8 +2497,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2495,8 +2516,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2540,21 +2562,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -2564,11 +2586,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2586,13 +2608,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2601,13 +2623,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -2618,7 +2640,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2628,7 +2650,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2638,13 +2660,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/fork_types.v b/CoqOfPython/ethereum/istanbul/fork_types.v index f19cd79..c223ec3 100644 --- a/CoqOfPython/ethereum/istanbul/fork_types.v +++ b/CoqOfPython/ethereum/istanbul/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.fork_types". +Definition globals : Globals.t := "ethereum.istanbul.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/istanbul/state.v b/CoqOfPython/ethereum/istanbul/state.v index d2aaed7..1cdbfcb 100644 --- a/CoqOfPython/ethereum/istanbul/state.v +++ b/CoqOfPython/ethereum/istanbul/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.state". +Definition globals : Globals.t := "ethereum.istanbul.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1163,19 +1191,20 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1194,14 +1223,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,18 +1243,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1234,7 +1263,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1242,7 +1271,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1255,10 +1284,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1266,14 +1295,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/transactions.v b/CoqOfPython/ethereum/istanbul/transactions.v index 0658f47..b3f8e81 100644 --- a/CoqOfPython/ethereum/istanbul/transactions.v +++ b/CoqOfPython/ethereum/istanbul/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.transactions". +Definition globals : Globals.t := "ethereum.istanbul.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/istanbul/trie.v b/CoqOfPython/ethereum/istanbul/trie.v index 0265390..9a208c8 100644 --- a/CoqOfPython/ethereum/istanbul/trie.v +++ b/CoqOfPython/ethereum/istanbul/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.trie". +Definition globals : Globals.t := "ethereum.istanbul.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_istanbul_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/utils/__init__.v b/CoqOfPython/ethereum/istanbul/utils/__init__.v index bcee1bf..6587917 100644 --- a/CoqOfPython/ethereum/istanbul/utils/__init__.v +++ b/CoqOfPython/ethereum/istanbul/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.utils.__init__". +Definition globals : Globals.t := "ethereum.istanbul.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/istanbul/utils/address.v b/CoqOfPython/ethereum/istanbul/utils/address.v index 340714a..6d4b32f 100644 --- a/CoqOfPython/ethereum/istanbul/utils/address.v +++ b/CoqOfPython/ethereum/istanbul/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.utils.address". +Definition globals : Globals.t := "ethereum.istanbul.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_istanbul_fork_types_imports_Address : IsImported globals "ethereum.istanbul.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/utils/hexadecimal.v b/CoqOfPython/ethereum/istanbul/utils/hexadecimal.v index 0486e96..326dbeb 100644 --- a/CoqOfPython/ethereum/istanbul/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/istanbul/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.istanbul.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_istanbul_fork_types_imports_Root : IsImported globals "ethereum.istanbul.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/istanbul/utils/message.v b/CoqOfPython/ethereum/istanbul/utils/message.v index 2ff4fec..764c0cc 100644 --- a/CoqOfPython/ethereum/istanbul/utils/message.v +++ b/CoqOfPython/ethereum/istanbul/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.utils.message". +Definition globals : Globals.t := "ethereum.istanbul.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_istanbul_utils_address_imports_compute_contract_address : IsImported globals "ethereum.istanbul.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -85,10 +88,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -97,20 +100,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -124,7 +127,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -133,7 +136,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -142,10 +145,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -153,19 +156,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -174,14 +177,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -192,7 +195,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -204,7 +207,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/vm/__init__.v b/CoqOfPython/ethereum/istanbul/vm/__init__.v index dc4ef8a..130d65d 100644 --- a/CoqOfPython/ethereum/istanbul/vm/__init__.v +++ b/CoqOfPython/ethereum/istanbul/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.__init__". +Definition globals : Globals.t := "ethereum.istanbul.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -95,8 +97,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -109,30 +112,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -140,19 +143,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,8 +167,9 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -180,15 +184,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -201,8 +205,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -210,19 +214,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -238,7 +242,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/exceptions.v b/CoqOfPython/ethereum/istanbul/vm/exceptions.v index 3ba8068..60bd736 100644 --- a/CoqOfPython/ethereum/istanbul/vm/exceptions.v +++ b/CoqOfPython/ethereum/istanbul/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.exceptions". +Definition globals : Globals.t := "ethereum.istanbul.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/istanbul/vm/gas.v b/CoqOfPython/ethereum/istanbul/vm/gas.v index b2000e8..ec6291f 100644 --- a/CoqOfPython/ethereum/istanbul/vm/gas.v +++ b/CoqOfPython/ethereum/istanbul/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.gas". +Definition globals : Globals.t := "ethereum.istanbul.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_istanbul_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 800 ], @@ -86,7 +88,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -116,7 +118,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -126,7 +128,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -136,7 +138,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -166,7 +168,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -176,7 +178,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -196,7 +198,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -206,7 +208,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -216,7 +218,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -226,7 +228,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -236,7 +238,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -246,7 +248,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -256,7 +258,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -266,7 +268,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -276,7 +278,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -286,7 +288,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -296,7 +298,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -306,7 +308,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -326,7 +328,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -336,7 +338,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -346,7 +348,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -356,7 +358,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -366,7 +368,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -376,7 +378,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -386,7 +388,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -396,7 +398,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -406,7 +408,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -416,7 +418,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -426,7 +428,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -436,7 +438,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -446,7 +448,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -456,7 +458,7 @@ Definition GAS_CODE_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -466,7 +468,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -495,8 +497,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -509,13 +512,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -526,22 +529,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -551,8 +554,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -572,9 +576,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -584,15 +588,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -601,16 +605,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -629,7 +634,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -639,7 +644,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -649,12 +654,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -664,14 +669,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -685,9 +690,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -695,20 +700,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -721,8 +726,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -736,16 +741,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -753,9 +758,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -764,13 +769,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -780,10 +785,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -791,8 +796,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -823,13 +829,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -837,32 +843,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -876,18 +882,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -898,15 +904,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -915,8 +921,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -932,9 +939,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/__init__.v b/CoqOfPython/ethereum/istanbul/vm/instructions/__init__.v index 645b22b..ac4aa10 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/istanbul/vm/instructions/arithmetic.v index 6c1634f..24ded16 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/bitwise.v b/CoqOfPython/ethereum/istanbul/vm/instructions/bitwise.v index cf2b256..9d39653 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/block.v b/CoqOfPython/ethereum/istanbul/vm/instructions/block.v index 9b0f81f..73b1cf4 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/block.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.block". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,14 +350,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -361,21 +370,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -384,7 +393,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/comparison.v b/CoqOfPython/ethereum/istanbul/vm/instructions/comparison.v index 3ddb9b3..9841d35 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/control_flow.v b/CoqOfPython/ethereum/istanbul/vm/instructions/control_flow.v index 540d4de..dc7875f 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/environment.v b/CoqOfPython/ethereum/istanbul/vm/instructions/environment.v index 6cda0d2..6d95393 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -78,8 +80,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -91,21 +94,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -114,14 +117,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -134,12 +138,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -148,42 +152,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -196,21 +201,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -219,14 +224,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -238,21 +244,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -261,14 +267,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -280,31 +287,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -318,30 +326,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -352,13 +360,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -367,14 +375,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -386,24 +395,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -415,14 +424,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -438,9 +448,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -448,9 +458,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -458,9 +468,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -469,12 +479,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -487,76 +497,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -568,24 +579,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -597,14 +608,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -620,9 +632,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -630,9 +642,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -640,9 +652,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -651,12 +663,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -669,76 +681,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -750,21 +763,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -773,14 +786,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -793,12 +807,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -807,26 +821,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -838,23 +852,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -867,12 +882,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -883,9 +898,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -893,9 +908,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -903,9 +918,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -914,12 +929,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -932,52 +947,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -985,34 +1000,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1023,24 +1039,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1052,14 +1068,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1071,9 +1088,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1081,9 +1098,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1091,9 +1108,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1102,12 +1119,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1120,108 +1137,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1232,12 +1250,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1246,20 +1264,20 @@ Definition extcodehash : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_CODE_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_CODE_HASH" |) ], make_dict [] |) in let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1268,15 +1286,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1289,12 +1307,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1305,23 +1323,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1333,35 +1352,35 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/keccak.v b/CoqOfPython/ethereum/istanbul/vm/instructions/keccak.v index e4fa0c2..f4f52cd 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/log.v b/CoqOfPython/ethereum/istanbul/vm/instructions/log.v index 8471fb8..aa83110 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/log.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.log". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_istanbul_vm_stack_imports_pop : IsImported globals "ethereum.istanbul.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/memory.v b/CoqOfPython/ethereum/istanbul/vm/instructions/memory.v index 139811a..813908d 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/stack.v b/CoqOfPython/ethereum/istanbul/vm/instructions/stack.v index 36a6974..f654b54 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_istanbul_vm_memory_imports_buffer_read : IsImported globals "ethereum.istanbul.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/storage.v b/CoqOfPython/ethereum/istanbul/vm/instructions/storage.v index e5e7cdf..19cb686 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -54,8 +56,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -70,9 +73,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -81,43 +84,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -131,9 +135,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -144,32 +148,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -177,11 +181,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -191,13 +195,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -207,21 +211,21 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -230,7 +234,7 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) |) in M.pure Constant.None_ )) |) in @@ -238,8 +242,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -248,18 +252,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -270,11 +274,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -289,12 +293,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -303,11 +307,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -321,8 +325,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -330,20 +334,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) |) ], make_dict [] @@ -354,13 +358,13 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) |) ], make_dict [] @@ -379,34 +383,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/instructions/system.v b/CoqOfPython/ethereum/istanbul/vm/instructions/system.v index 04f4e5a..c384f87 100644 --- a/CoqOfPython/ethereum/istanbul/vm/instructions/system.v +++ b/CoqOfPython/ethereum/istanbul/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.instructions.system". +Definition globals : Globals.t := "ethereum.istanbul.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,8 +107,9 @@ Axiom ethereum_istanbul_vm_stack_imports_push : IsImported globals "ethereum.istanbul.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in @@ -114,12 +117,12 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -129,32 +132,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -164,15 +167,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -188,10 +191,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -201,15 +204,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -230,29 +233,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -272,27 +275,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -300,10 +303,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -311,27 +314,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -344,25 +347,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -374,8 +377,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -387,9 +391,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,9 +401,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -407,9 +411,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -417,46 +421,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -465,26 +469,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -499,9 +504,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -509,9 +514,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -519,9 +524,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -530,9 +535,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -543,11 +548,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -557,12 +562,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -573,43 +578,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -618,26 +623,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -649,9 +655,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -659,9 +665,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -669,63 +675,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -733,24 +740,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -770,11 +777,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -782,10 +789,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -793,7 +800,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -801,10 +808,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -812,27 +819,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -845,23 +852,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -875,16 +882,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -896,14 +903,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -912,8 +919,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -925,12 +933,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -941,12 +949,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -957,9 +965,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,9 +975,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -977,9 +985,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -987,9 +995,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -997,9 +1005,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1007,12 +1015,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1024,15 +1032,15 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), ltac:(M.monadic ( M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) @@ -1041,7 +1049,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1049,7 +1057,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1057,13 +1065,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1071,56 +1079,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1129,25 +1137,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1156,17 +1164,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1176,32 +1184,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1209,14 +1217,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1228,12 +1237,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1244,12 +1253,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1260,9 +1269,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1270,9 +1279,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,9 +1289,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1290,9 +1299,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1300,26 +1309,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1330,13 +1339,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1344,58 +1353,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1404,17 +1413,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1424,32 +1433,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1457,14 +1466,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1476,12 +1486,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1491,27 +1501,27 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1524,7 +1534,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1533,33 +1543,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1571,15 +1581,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1587,28 +1597,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1616,33 +1626,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1652,9 +1662,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1662,19 +1672,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1684,15 +1694,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1704,12 +1715,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1720,12 +1731,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1736,9 +1747,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1746,9 +1757,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1756,9 +1767,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1766,9 +1777,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,12 +1787,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1790,76 +1801,77 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1871,12 +1883,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1887,12 +1899,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1903,9 +1915,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1913,9 +1925,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1923,9 +1935,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1933,9 +1945,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1943,12 +1955,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1957,82 +1969,83 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2044,9 +2057,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2054,9 +2067,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2064,54 +2077,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/interpreter.v b/CoqOfPython/ethereum/istanbul/vm/interpreter.v index dc57fbf..c35bb38 100644 --- a/CoqOfPython/ethereum/istanbul/vm/interpreter.v +++ b/CoqOfPython/ethereum/istanbul/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.interpreter". +Definition globals : Globals.t := "ethereum.istanbul.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -124,7 +126,7 @@ Axiom ethereum_istanbul_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -147,8 +149,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -170,9 +173,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -184,10 +187,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -195,44 +198,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -246,10 +249,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -262,10 +265,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -274,13 +277,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -290,12 +293,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -312,14 +315,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -327,7 +330,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -335,7 +338,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -347,22 +350,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -372,29 +375,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -402,8 +405,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -420,43 +424,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -464,24 +468,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -489,22 +493,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -524,13 +529,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -542,17 +547,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -560,10 +565,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -571,12 +576,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -588,10 +593,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -599,13 +604,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -613,22 +618,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -646,14 +652,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -661,13 +667,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/memory.v b/CoqOfPython/ethereum/istanbul/vm/memory.v index 743e878..a1df5bc 100644 --- a/CoqOfPython/ethereum/istanbul/vm/memory.v +++ b/CoqOfPython/ethereum/istanbul/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.memory". +Definition globals : Globals.t := "ethereum.istanbul.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/__init__.v index 1419ef4..d4f03ea 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/alt_bn128.v index e074092..3827717 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_istanbul_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.istanbul.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/blake2f.v index da836ff..61318dc 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_istanbul_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.istanbul.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ecrecover.v index de71626..1cee0f2 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_istanbul_vm_memory_imports_buffer_read : IsImported globals "ethereum.istanbul.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/identity.v index 894529f..2387288 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_istanbul_vm_gas_imports_charge_gas : IsImported globals "ethereum.istanbul.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/mapping.v index d88667d..a8e754d 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/modexp.v index 6178170..575a5b6 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,7 +37,7 @@ Axiom ethereum_istanbul_vm_memory_imports_buffer_read : Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -44,34 +46,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -87,21 +90,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -117,21 +120,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -148,36 +151,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -192,7 +195,7 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "exp_length" |), + M.get_name (| globals, locals_stack, "exp_length" |), Constant.int 32 |), (* then *) @@ -200,15 +203,15 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -227,16 +230,16 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |), @@ -244,12 +247,12 @@ Definition modexp : Value.t -> Value.t -> M := |) |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -266,22 +269,22 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.floor_div (| BinOp.mult (| M.call (| - M.get_name (| globals, "get_mult_complexity" |), + M.get_name (| globals, locals_stack, "get_mult_complexity" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -292,11 +295,11 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "adjusted_exp_length" |); + M.get_name (| globals, locals_stack, "adjusted_exp_length" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -306,7 +309,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |) |), - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) ], make_dict [] @@ -316,12 +319,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -329,9 +332,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -347,20 +350,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -371,14 +374,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -389,21 +392,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -415,39 +418,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -455,7 +458,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -466,8 +469,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_mult_complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing Karatsuba multiplication. " in @@ -475,14 +479,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 64 |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |) |) in @@ -493,7 +497,7 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 1024 |), (* then *) @@ -503,14 +507,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 4 |), BinOp.mult (| Constant.int 96, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 3072 @@ -524,14 +528,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 16 |), BinOp.mult (| Constant.int 480, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 199680 diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ripemd160.v index 9355562..5e50193 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_istanbul_vm_gas_imports_charge_gas : IsImported globals "ethereum.istanbul.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/sha256.v index 36128c8..e2ba3ba 100644 --- a/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/istanbul/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.istanbul.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_istanbul_vm_gas_imports_charge_gas : IsImported globals "ethereum.istanbul.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/istanbul/vm/runtime.v b/CoqOfPython/ethereum/istanbul/vm/runtime.v index 88abdd0..d074968 100644 --- a/CoqOfPython/ethereum/istanbul/vm/runtime.v +++ b/CoqOfPython/ethereum/istanbul/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.runtime". +Definition globals : Globals.t := "ethereum.istanbul.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_istanbul_vm_instructions_imports_Ops : IsImported globals "ethereum.istanbul.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/istanbul/vm/stack.v b/CoqOfPython/ethereum/istanbul/vm/stack.v index 8a72fb1..5e0db23 100644 --- a/CoqOfPython/ethereum/istanbul/vm/stack.v +++ b/CoqOfPython/ethereum/istanbul/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.istanbul.vm.stack". +Definition globals : Globals.t := "ethereum.istanbul.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_istanbul_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.istanbul.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/__init__.v b/CoqOfPython/ethereum/london/__init__.v index d0a16e4..1653ae0 100644 --- a/CoqOfPython/ethereum/london/__init__.v +++ b/CoqOfPython/ethereum/london/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.__init__". +Definition globals : Globals.t := "ethereum.london.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -13,7 +15,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 12965000 ], diff --git a/CoqOfPython/ethereum/london/blocks.v b/CoqOfPython/ethereum/london/blocks.v index acc6316..9c5e31a 100644 --- a/CoqOfPython/ethereum/london/blocks.v +++ b/CoqOfPython/ethereum/london/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.blocks". +Definition globals : Globals.t := "ethereum.london.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/london/bloom.v b/CoqOfPython/ethereum/london/bloom.v index ede68b4..8048cd3 100644 --- a/CoqOfPython/ethereum/london/bloom.v +++ b/CoqOfPython/ethereum/london/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.bloom". +Definition globals : Globals.t := "ethereum.london.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_london_fork_types_imports_Bloom : IsImported globals "ethereum.london.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/fork.v b/CoqOfPython/ethereum/london/fork.v index 2a268b2..0213a39 100644 --- a/CoqOfPython/ethereum/london/fork.v +++ b/CoqOfPython/ethereum/london/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.fork". +Definition globals : Globals.t := "ethereum.london.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -152,7 +154,7 @@ Axiom ethereum_london_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -184,7 +186,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -206,10 +208,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -231,8 +233,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -252,13 +255,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -281,7 +285,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -292,9 +296,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -316,17 +320,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -339,13 +343,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -356,20 +360,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -394,112 +399,112 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "base_fee_per_gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "base_fee_per_gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -508,9 +513,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -519,9 +524,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -535,8 +540,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas"; "is_fork_block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas"; "is_fork_block" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the base fee per gas for the block. @@ -561,14 +567,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_fork_block" |), + M.get_name (| globals, locals_stack, "is_fork_block" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "INITIAL_BASE_FEE" |) + M.get_name (| globals, locals_stack, "INITIAL_BASE_FEE" |) ], make_dict [] |) @@ -581,22 +587,22 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_gas_target" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "ELASTICITY_MULTIPLIER" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "ELASTICITY_MULTIPLIER" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_name (| globals, "block_gas_limit" |); - M.get_name (| globals, "parent_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |); + M.get_name (| globals, locals_stack, "parent_gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -604,14 +610,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "expected_base_fee_per_gas" , - M.get_name (| globals, "parent_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |) |) in M.pure Constant.None_ (* else *) @@ -620,40 +626,40 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |); Constant.int 1 ], @@ -663,8 +669,8 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.add (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -673,36 +679,36 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_target" |), - M.get_name (| globals, "parent_gas_used" |) + M.get_name (| globals, locals_stack, "parent_gas_target" |), + M.get_name (| globals, locals_stack, "parent_gas_used" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.sub (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -711,9 +717,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "expected_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |) ], make_dict [] |) @@ -721,8 +727,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -741,131 +748,131 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |), - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "is_fork_block" , Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), - M.get_field (| M.get_name (| globals, "FORK_CRITERIA" |), "block_number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "FORK_CRITERIA" |), "block_number" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , M.call (| - M.get_name (| globals, "calculate_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "calculate_base_fee_per_gas" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "base_fee_per_gas" |); - M.get_name (| globals, "is_fork_block" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "is_fork_block" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "expected_base_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -874,28 +881,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -921,27 +929,27 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |); - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -949,8 +957,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -968,9 +977,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -978,25 +987,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -1005,41 +1014,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -1067,23 +1077,23 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1092,46 +1102,46 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "priority_fee_per_gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) ], make_dict [] @@ -1140,38 +1150,39 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_price" , BinOp.add (| - M.get_name (| globals, "priority_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_price" , - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ] |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -1195,7 +1206,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -1204,10 +1215,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -1217,9 +1228,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1232,10 +1243,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1245,9 +1256,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1257,7 +1268,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -1276,8 +1287,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -1322,22 +1334,22 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1346,16 +1358,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1363,9 +1375,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1373,14 +1385,14 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ], M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "base_fee_per_gas" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -1388,18 +1400,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1407,49 +1419,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1458,56 +1470,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1518,8 +1530,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1544,27 +1557,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1573,9 +1586,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1593,46 +1606,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1643,19 +1656,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1664,23 +1677,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1688,16 +1701,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1711,13 +1724,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1732,11 +1745,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1744,88 +1757,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1838,8 +1851,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1868,44 +1882,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1917,19 +1931,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1942,8 +1956,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1971,30 +1986,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -2003,10 +2018,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2015,8 +2030,8 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |) |) |) in M.pure Constant.None_ @@ -2025,100 +2040,100 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "max_gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "max_gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "effective_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "effective_gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2126,7 +2141,7 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -2135,10 +2150,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2146,25 +2161,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -2188,14 +2203,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2203,10 +2218,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -2214,20 +2229,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 5 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -2236,17 +2251,17 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "priority_fee_per_gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |), - M.get_field (| M.get_name (| globals, "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| @@ -2254,41 +2269,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_name (| globals, "priority_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -2296,31 +2311,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -2331,20 +2346,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -2357,14 +2372,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2376,27 +2391,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -2412,13 +2427,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -2447,17 +2463,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -2472,8 +2488,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -2502,14 +2519,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2517,7 +2534,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2525,7 +2542,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2539,9 +2556,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2552,7 +2569,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2571,10 +2588,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2582,26 +2599,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -2617,17 +2634,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -2636,8 +2653,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2660,47 +2678,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2708,10 +2726,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2719,19 +2737,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2741,18 +2759,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2764,58 +2782,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2832,10 +2850,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2844,15 +2862,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2867,10 +2885,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2879,15 +2897,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_1559" |), + M.get_name (| globals, locals_stack, "signing_hash_1559" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2906,13 +2924,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2927,8 +2945,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2944,12 +2963,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2960,8 +2979,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2979,19 +2999,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -3007,8 +3027,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -3024,14 +3045,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -3043,8 +3064,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_1559 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 1559 signature. @@ -3060,14 +3082,14 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -3079,8 +3101,9 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -3114,12 +3137,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -3130,8 +3153,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -3162,18 +3186,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3190,10 +3214,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -3210,8 +3234,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -3229,8 +3253,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -3274,21 +3299,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -3298,11 +3323,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -3320,13 +3345,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -3335,13 +3360,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -3352,7 +3377,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -3362,7 +3387,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -3372,13 +3397,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/fork_types.v b/CoqOfPython/ethereum/london/fork_types.v index 3c5e125..2dbc932 100644 --- a/CoqOfPython/ethereum/london/fork_types.v +++ b/CoqOfPython/ethereum/london/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.fork_types". +Definition globals : Globals.t := "ethereum.london.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/london/state.v b/CoqOfPython/ethereum/london/state.v index afa32da..4eab149 100644 --- a/CoqOfPython/ethereum/london/state.v +++ b/CoqOfPython/ethereum/london/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.state". +Definition globals : Globals.t := "ethereum.london.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1163,19 +1191,20 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1194,14 +1223,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,18 +1243,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1234,7 +1263,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1242,7 +1271,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1255,10 +1284,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1266,14 +1295,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/transactions.v b/CoqOfPython/ethereum/london/transactions.v index 432578b..bf51ad0 100644 --- a/CoqOfPython/ethereum/london/transactions.v +++ b/CoqOfPython/ethereum/london/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.transactions". +Definition globals : Globals.t := "ethereum.london.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,14 +99,15 @@ Definition FeeMarketTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -112,17 +115,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -131,10 +134,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -144,9 +147,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -159,10 +162,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -172,9 +175,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -184,7 +187,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -199,8 +202,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -208,10 +212,10 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), @@ -222,7 +226,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 @@ -231,11 +235,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -252,7 +256,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 2 @@ -261,11 +265,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "FeeMarketTransaction" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -277,7 +281,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ @@ -286,7 +290,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/london/trie.v b/CoqOfPython/ethereum/london/trie.v index dac8ce1..ba27f23 100644 --- a/CoqOfPython/ethereum/london/trie.v +++ b/CoqOfPython/ethereum/london/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.trie". +Definition globals : Globals.t := "ethereum.london.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_london_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,34 +124,34 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -187,14 +189,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -218,7 +221,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -234,10 +237,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -246,13 +249,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -261,10 +264,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -273,13 +276,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -288,10 +291,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -300,9 +303,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -310,7 +313,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -327,9 +330,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -339,9 +342,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -350,16 +353,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -369,8 +372,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -380,25 +384,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -410,10 +414,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -421,13 +425,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -442,27 +446,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -486,8 +490,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -504,14 +509,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -522,8 +527,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -543,8 +549,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -552,14 +558,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -571,18 +577,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -602,10 +609,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -613,21 +620,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -640,11 +648,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -652,12 +660,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -665,7 +673,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -680,9 +688,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -690,8 +698,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -728,7 +737,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -739,9 +748,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -752,13 +761,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -766,15 +775,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -784,20 +793,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -815,7 +824,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -823,13 +832,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -838,15 +847,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -856,20 +865,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -887,9 +896,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -897,8 +906,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -915,14 +925,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -933,26 +943,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -960,17 +970,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -982,9 +992,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -992,8 +1002,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1014,9 +1025,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1025,25 +1036,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1051,13 +1062,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1071,9 +1082,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1081,13 +1092,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1095,15 +1106,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1113,22 +1124,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1137,13 +1148,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1164,10 +1176,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1175,14 +1187,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1200,12 +1212,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1218,12 +1230,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1235,18 +1247,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1256,8 +1268,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1281,9 +1294,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1302,12 +1315,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1320,9 +1333,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1333,24 +1346,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1360,8 +1373,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1369,31 +1382,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1408,7 +1421,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1429,7 +1442,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1437,30 +1450,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1480,9 +1493,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1490,7 +1503,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1508,21 +1521,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1530,19 +1543,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1551,8 +1564,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1561,17 +1574,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1584,10 +1597,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/utils/__init__.v b/CoqOfPython/ethereum/london/utils/__init__.v index 3cb26eb..75f82ef 100644 --- a/CoqOfPython/ethereum/london/utils/__init__.v +++ b/CoqOfPython/ethereum/london/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.utils.__init__". +Definition globals : Globals.t := "ethereum.london.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/london/utils/address.v b/CoqOfPython/ethereum/london/utils/address.v index f43bd88..89e5262 100644 --- a/CoqOfPython/ethereum/london/utils/address.v +++ b/CoqOfPython/ethereum/london/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.utils.address". +Definition globals : Globals.t := "ethereum.london.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_london_fork_types_imports_Address : IsImported globals "ethereum.london.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/utils/hexadecimal.v b/CoqOfPython/ethereum/london/utils/hexadecimal.v index 94f210a..c646db7 100644 --- a/CoqOfPython/ethereum/london/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/london/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.london.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_london_fork_types_imports_Root : IsImported globals "ethereum.london.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/london/utils/message.v b/CoqOfPython/ethereum/london/utils/message.v index 573dcf4..3c0fb98 100644 --- a/CoqOfPython/ethereum/london/utils/message.v +++ b/CoqOfPython/ethereum/london/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.utils.message". +Definition globals : Globals.t := "ethereum.london.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_london_utils_address_imports_compute_contract_address : IsImported globals "ethereum.london.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/vm/__init__.v b/CoqOfPython/ethereum/london/vm/__init__.v index 9d60f4a..e177f5b 100644 --- a/CoqOfPython/ethereum/london/vm/__init__.v +++ b/CoqOfPython/ethereum/london/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.__init__". +Definition globals : Globals.t := "ethereum.london.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,8 +99,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -111,30 +114,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -142,19 +145,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,24 +167,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -196,15 +200,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -217,8 +221,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -226,19 +230,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -254,7 +258,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/exceptions.v b/CoqOfPython/ethereum/london/vm/exceptions.v index 277efd6..9c5da7a 100644 --- a/CoqOfPython/ethereum/london/vm/exceptions.v +++ b/CoqOfPython/ethereum/london/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.exceptions". +Definition globals : Globals.t := "ethereum.london.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/london/vm/gas.v b/CoqOfPython/ethereum/london/vm/gas.v index 08eb313..5e6fbd5 100644 --- a/CoqOfPython/ethereum/london/vm/gas.v +++ b/CoqOfPython/ethereum/london/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.gas". +Definition globals : Globals.t := "ethereum.london.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_london_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -86,7 +88,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 4800 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -116,7 +118,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -126,7 +128,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -136,7 +138,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -166,7 +168,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -176,7 +178,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -196,7 +198,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -206,7 +208,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -216,7 +218,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -226,7 +228,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -236,7 +238,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -246,7 +248,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -256,7 +258,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -266,7 +268,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -276,7 +278,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -286,7 +288,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -296,7 +298,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -306,7 +308,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -326,7 +328,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -336,7 +338,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -346,7 +348,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -356,7 +358,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -366,7 +368,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -376,7 +378,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -386,7 +388,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -396,7 +398,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -406,7 +408,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -416,7 +418,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -426,7 +428,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -436,7 +438,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -465,8 +467,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -479,13 +482,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -496,22 +499,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -521,8 +524,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -542,9 +546,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -554,15 +558,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -571,16 +575,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,12 +624,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -634,14 +639,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -655,9 +660,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -665,20 +670,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -691,8 +696,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -706,16 +711,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -723,9 +728,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -734,13 +739,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -750,10 +755,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -761,8 +766,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -793,13 +799,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -807,32 +813,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -846,18 +852,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -868,15 +874,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -885,8 +891,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -902,9 +909,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/london/vm/instructions/__init__.v b/CoqOfPython/ethereum/london/vm/instructions/__init__.v index ed385be..3d27c13 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/london/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.london.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/london/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/london/vm/instructions/arithmetic.v index 1b66ceb..ce2405b 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/london/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.london.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/bitwise.v b/CoqOfPython/ethereum/london/vm/instructions/bitwise.v index 02bebb6..dfc49eb 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/london/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.london.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/block.v b/CoqOfPython/ethereum/london/vm/instructions/block.v index e3bee4c..a61620f 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/block.v +++ b/CoqOfPython/ethereum/london/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.block". +Definition globals : Globals.t := "ethereum.london.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,14 +350,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -361,21 +370,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -384,7 +393,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/comparison.v b/CoqOfPython/ethereum/london/vm/instructions/comparison.v index 4a78f2d..75c4043 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/london/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.london.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/control_flow.v b/CoqOfPython/ethereum/london/vm/instructions/control_flow.v index 263e036..b27e30e 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/london/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.london.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/environment.v b/CoqOfPython/ethereum/london/vm/instructions/environment.v index f91ee73..69d9988 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/london/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.london.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -149,16 +153,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -166,17 +170,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -185,32 +189,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -223,21 +228,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -246,14 +251,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -265,21 +271,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -288,14 +294,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -307,31 +314,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -345,30 +353,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -379,13 +387,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -394,14 +402,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -413,24 +422,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -442,14 +451,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -465,9 +475,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -475,9 +485,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -485,9 +495,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -496,12 +506,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -514,76 +524,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -595,24 +606,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -624,14 +635,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -647,9 +659,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -657,9 +669,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -667,9 +679,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,12 +690,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -696,76 +708,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -777,21 +790,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -800,14 +813,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -820,12 +834,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -837,16 +851,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -854,17 +868,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -873,16 +887,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -894,23 +908,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -923,12 +938,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -939,9 +954,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -949,9 +964,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -959,9 +974,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -970,12 +985,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -988,18 +1003,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1009,21 +1024,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1032,22 +1047,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1056,19 +1071,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1076,34 +1091,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1114,24 +1130,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1143,14 +1159,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1162,9 +1179,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1172,9 +1189,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1182,9 +1199,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1193,12 +1210,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1211,108 +1228,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1323,12 +1341,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1340,16 +1358,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1357,17 +1375,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1376,10 +1394,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1388,15 +1406,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1409,12 +1427,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1425,23 +1443,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1453,42 +1472,43 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the base fee of the current block on to the stack. @@ -1500,21 +1520,21 @@ Definition base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "base_fee_per_gas" |) ], make_dict [] |) @@ -1523,7 +1543,7 @@ Definition base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/keccak.v b/CoqOfPython/ethereum/london/vm/instructions/keccak.v index ddef676..6f443d1 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/london/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.london.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/log.v b/CoqOfPython/ethereum/london/vm/instructions/log.v index 8122664..24b0aa1 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/log.v +++ b/CoqOfPython/ethereum/london/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.log". +Definition globals : Globals.t := "ethereum.london.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_london_vm_stack_imports_pop : IsImported globals "ethereum.london.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/vm/instructions/memory.v b/CoqOfPython/ethereum/london/vm/instructions/memory.v index 494a8b3..35a385e 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/london/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.london.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/stack.v b/CoqOfPython/ethereum/london/vm/instructions/stack.v index b5976e8..8bc2b0c 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/london/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.london.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_london_vm_memory_imports_buffer_read : IsImported globals "ethereum.london.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/vm/instructions/storage.v b/CoqOfPython/ethereum/london/vm/instructions/storage.v index ed374ae..e8cbac7 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/london/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.london.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -59,8 +61,9 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -75,9 +78,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -89,16 +92,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -106,17 +109,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -125,33 +128,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -165,9 +169,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -178,32 +182,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -211,11 +215,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -223,7 +227,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -234,22 +238,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -261,13 +265,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -277,7 +281,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -285,7 +289,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -294,8 +298,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -306,7 +310,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -314,8 +318,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -324,18 +328,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -346,11 +350,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -365,12 +369,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -379,11 +383,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -397,8 +401,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -406,20 +410,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -430,16 +434,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -458,34 +462,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/instructions/system.v b/CoqOfPython/ethereum/london/vm/instructions/system.v index a747adf..2cc7d6e 100644 --- a/CoqOfPython/ethereum/london/vm/instructions/system.v +++ b/CoqOfPython/ethereum/london/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.instructions.system". +Definition globals : Globals.t := "ethereum.london.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,28 +107,29 @@ Axiom ethereum_london_vm_stack_imports_push : IsImported globals "ethereum.london.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -136,32 +139,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -171,15 +174,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -195,10 +198,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -208,15 +211,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -237,29 +240,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -279,27 +282,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -307,10 +310,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -318,27 +321,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,25 +354,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -381,8 +384,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -394,9 +398,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -404,9 +408,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -414,9 +418,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -424,46 +428,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -472,26 +476,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -506,9 +511,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -516,9 +521,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -526,9 +531,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -537,9 +542,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -550,11 +555,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -564,12 +569,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -580,43 +585,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -625,26 +630,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -656,9 +662,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -666,9 +672,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -676,63 +682,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -740,24 +747,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -777,11 +784,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -789,10 +796,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -800,7 +807,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -808,10 +815,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -819,27 +826,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -852,23 +859,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -882,16 +889,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -903,14 +910,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -919,8 +926,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -932,12 +940,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -948,12 +956,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -964,9 +972,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -974,9 +982,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -984,9 +992,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -994,9 +1002,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1004,9 +1012,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1014,12 +1022,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1029,28 +1037,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1060,16 +1068,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1077,7 +1085,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1085,7 +1093,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1093,13 +1101,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1107,56 +1115,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1165,25 +1173,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1192,17 +1200,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1212,32 +1220,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1245,14 +1253,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1264,12 +1273,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,12 +1289,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1296,9 +1305,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,9 +1315,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1316,9 +1325,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1326,9 +1335,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1336,26 +1345,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1365,28 +1374,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1395,13 +1404,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1409,58 +1418,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1469,17 +1478,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1489,32 +1498,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1522,14 +1531,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1541,12 +1551,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1556,28 +1566,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1589,20 +1599,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1615,7 +1625,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1623,32 +1633,32 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1656,33 +1666,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1692,9 +1702,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1702,19 +1712,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1724,15 +1734,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1744,12 +1755,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1760,12 +1771,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,9 +1787,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1786,9 +1797,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1796,9 +1807,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1806,9 +1817,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1816,12 +1827,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1831,104 +1842,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1940,12 +1952,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1956,12 +1968,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1972,9 +1984,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1982,9 +1994,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1992,9 +2004,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2002,9 +2014,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2012,12 +2024,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2027,110 +2039,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2142,9 +2155,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2152,9 +2165,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2162,54 +2175,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/interpreter.v b/CoqOfPython/ethereum/london/vm/interpreter.v index 6398f45..01a4ef3 100644 --- a/CoqOfPython/ethereum/london/vm/interpreter.v +++ b/CoqOfPython/ethereum/london/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.interpreter". +Definition globals : Globals.t := "ethereum.london.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -126,7 +128,7 @@ Axiom ethereum_london_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -149,8 +151,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -172,9 +175,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -186,10 +189,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -197,44 +200,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -248,10 +251,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -264,10 +267,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -276,13 +279,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -292,12 +295,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -314,14 +317,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -329,7 +332,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -337,7 +340,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -349,22 +352,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -374,29 +377,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -404,8 +407,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -422,43 +426,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -466,24 +470,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -491,22 +495,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -526,13 +531,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -544,17 +549,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -562,10 +567,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -573,12 +578,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -590,10 +595,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -601,13 +606,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -615,22 +620,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -648,14 +654,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -663,13 +669,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/memory.v b/CoqOfPython/ethereum/london/vm/memory.v index 69b3e08..84e2145 100644 --- a/CoqOfPython/ethereum/london/vm/memory.v +++ b/CoqOfPython/ethereum/london/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.memory". +Definition globals : Globals.t := "ethereum.london.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/__init__.v index 3866316..1bdd648 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/alt_bn128.v index 40ca063..5026931 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_london_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.london.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/blake2f.v index 19507e0..3cbabcc 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_london_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.london.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/ecrecover.v index 30d0b1a..cae6267 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_london_vm_memory_imports_buffer_read : IsImported globals "ethereum.london.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/identity.v index df382e7..421b701 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_london_vm_gas_imports_charge_gas : IsImported globals "ethereum.london.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/mapping.v index 021da76..2b1cffd 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/modexp.v index 638770d..9c7c360 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/ripemd160.v index 9c8567e..6a3952c 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_london_vm_gas_imports_charge_gas : IsImported globals "ethereum.london.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/london/vm/precompiled_contracts/sha256.v index ea0b74a..f1b4b78 100644 --- a/CoqOfPython/ethereum/london/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/london/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.london.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_london_vm_gas_imports_charge_gas : IsImported globals "ethereum.london.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/london/vm/runtime.v b/CoqOfPython/ethereum/london/vm/runtime.v index 0b7292e..431534c 100644 --- a/CoqOfPython/ethereum/london/vm/runtime.v +++ b/CoqOfPython/ethereum/london/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.runtime". +Definition globals : Globals.t := "ethereum.london.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_london_vm_instructions_imports_Ops : IsImported globals "ethereum.london.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/london/vm/stack.v b/CoqOfPython/ethereum/london/vm/stack.v index 745ac5c..4a1ee77 100644 --- a/CoqOfPython/ethereum/london/vm/stack.v +++ b/CoqOfPython/ethereum/london/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.london.vm.stack". +Definition globals : Globals.t := "ethereum.london.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_london_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.london.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/__init__.v b/CoqOfPython/ethereum/muir_glacier/__init__.v index bb77935..0fc2600 100644 --- a/CoqOfPython/ethereum/muir_glacier/__init__.v +++ b/CoqOfPython/ethereum/muir_glacier/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.__init__". +Definition globals : Globals.t := "ethereum.muir_glacier.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -13,7 +15,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 9200000 ], diff --git a/CoqOfPython/ethereum/muir_glacier/blocks.v b/CoqOfPython/ethereum/muir_glacier/blocks.v index 2a404eb..7b797d3 100644 --- a/CoqOfPython/ethereum/muir_glacier/blocks.v +++ b/CoqOfPython/ethereum/muir_glacier/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.blocks". +Definition globals : Globals.t := "ethereum.muir_glacier.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/muir_glacier/bloom.v b/CoqOfPython/ethereum/muir_glacier/bloom.v index ee72a93..0b50d31 100644 --- a/CoqOfPython/ethereum/muir_glacier/bloom.v +++ b/CoqOfPython/ethereum/muir_glacier/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.bloom". +Definition globals : Globals.t := "ethereum.muir_glacier.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_muir_glacier_fork_types_imports_Bloom : IsImported globals "ethereum.muir_glacier.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/fork.v b/CoqOfPython/ethereum/muir_glacier/fork.v index 7b80d97..1e7076d 100644 --- a/CoqOfPython/ethereum/muir_glacier/fork.v +++ b/CoqOfPython/ethereum/muir_glacier/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.fork". +Definition globals : Globals.t := "ethereum.muir_glacier.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -134,7 +136,7 @@ Axiom ethereum_muir_glacier_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 2, @@ -158,7 +160,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -176,10 +178,10 @@ Definition BOMB_DELAY_BLOCKS : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -201,8 +203,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -222,13 +225,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -251,7 +255,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -262,9 +266,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -286,17 +290,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -309,13 +313,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -326,20 +330,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -364,111 +369,111 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -477,9 +482,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -488,9 +493,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -504,8 +509,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -526,101 +532,101 @@ Definition validate_header : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_has_ommers" , Compare.not_eq (| - M.get_field (| M.get_name (| globals, "parent_header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |); - M.get_name (| globals, "parent_has_ommers" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |); + M.get_name (| globals, locals_stack, "parent_has_ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -629,28 +635,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -676,26 +683,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -703,8 +710,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -722,9 +730,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -732,25 +740,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -759,41 +767,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -817,35 +826,36 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -869,13 +879,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -890,8 +900,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -934,51 +945,51 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -986,18 +997,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1005,49 +1016,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1056,56 +1067,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1116,8 +1127,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1142,27 +1154,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1171,9 +1183,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1191,46 +1203,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1241,19 +1253,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1262,23 +1274,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1286,16 +1298,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1309,13 +1321,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1330,11 +1342,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1342,88 +1354,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1436,8 +1448,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1466,44 +1479,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1515,19 +1528,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1540,8 +1553,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1569,30 +1583,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1600,98 +1614,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1699,10 +1713,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1710,20 +1724,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1732,10 +1746,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1743,41 +1757,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1785,31 +1799,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1820,20 +1834,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1846,14 +1860,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1865,27 +1879,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1901,13 +1915,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1936,17 +1951,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1961,8 +1976,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1991,14 +2007,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2006,7 +2022,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2014,7 +2030,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2028,9 +2044,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2041,7 +2057,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2054,14 +2070,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -2070,8 +2086,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2094,47 +2111,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2143,12 +2160,12 @@ Definition recover_sender : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2158,18 +2175,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2181,58 +2198,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2244,13 +2261,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2265,8 +2282,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2282,12 +2300,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2298,8 +2316,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2317,19 +2336,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2345,8 +2364,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2380,12 +2400,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2396,8 +2416,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2428,18 +2449,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2456,10 +2477,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2476,8 +2497,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2495,8 +2516,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty"; "parent_has_ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2540,21 +2562,21 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| (* if *) M.if_then_else (| - M.get_name (| globals, "parent_has_ommers" |), + M.get_name (| globals, locals_stack, "parent_has_ommers" |), (* then *) ltac:(M.monadic ( Constant.int 2 @@ -2564,11 +2586,11 @@ Constant.int 1 )) |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2586,13 +2608,13 @@ Constant.int 1 "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2601,13 +2623,13 @@ Constant.int 1 BinOp.floor_div (| BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), - M.get_name (| globals, "BOMB_DELAY_BLOCKS" |) + M.get_name (| globals, locals_stack, "BOMB_DELAY_BLOCKS" |) |), Constant.int 100000 |), @@ -2618,7 +2640,7 @@ Constant.int 1 (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2628,7 +2650,7 @@ Constant.int 1 "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2638,13 +2660,13 @@ Constant.int 1 )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/fork_types.v b/CoqOfPython/ethereum/muir_glacier/fork_types.v index 100f313..54e2920 100644 --- a/CoqOfPython/ethereum/muir_glacier/fork_types.v +++ b/CoqOfPython/ethereum/muir_glacier/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.fork_types". +Definition globals : Globals.t := "ethereum.muir_glacier.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/muir_glacier/state.v b/CoqOfPython/ethereum/muir_glacier/state.v index 28df1ec..a29a84b 100644 --- a/CoqOfPython/ethereum/muir_glacier/state.v +++ b/CoqOfPython/ethereum/muir_glacier/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.state". +Definition globals : Globals.t := "ethereum.muir_glacier.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1163,19 +1191,20 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1194,14 +1223,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1214,18 +1243,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1234,7 +1263,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1242,7 +1271,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1255,10 +1284,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1266,14 +1295,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/transactions.v b/CoqOfPython/ethereum/muir_glacier/transactions.v index 0443ebc..b62f546 100644 --- a/CoqOfPython/ethereum/muir_glacier/transactions.v +++ b/CoqOfPython/ethereum/muir_glacier/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.transactions". +Definition globals : Globals.t := "ethereum.muir_glacier.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/muir_glacier/trie.v b/CoqOfPython/ethereum/muir_glacier/trie.v index 5e9b0cd..864cfc2 100644 --- a/CoqOfPython/ethereum/muir_glacier/trie.v +++ b/CoqOfPython/ethereum/muir_glacier/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.trie". +Definition globals : Globals.t := "ethereum.muir_glacier.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_muir_glacier_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/utils/__init__.v b/CoqOfPython/ethereum/muir_glacier/utils/__init__.v index d8eb235..21c7ec2 100644 --- a/CoqOfPython/ethereum/muir_glacier/utils/__init__.v +++ b/CoqOfPython/ethereum/muir_glacier/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.utils.__init__". +Definition globals : Globals.t := "ethereum.muir_glacier.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/muir_glacier/utils/address.v b/CoqOfPython/ethereum/muir_glacier/utils/address.v index 7c8c1f0..eb42dd0 100644 --- a/CoqOfPython/ethereum/muir_glacier/utils/address.v +++ b/CoqOfPython/ethereum/muir_glacier/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.utils.address". +Definition globals : Globals.t := "ethereum.muir_glacier.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_muir_glacier_fork_types_imports_Address : IsImported globals "ethereum.muir_glacier.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/utils/hexadecimal.v b/CoqOfPython/ethereum/muir_glacier/utils/hexadecimal.v index 56e0dcc..42f88f5 100644 --- a/CoqOfPython/ethereum/muir_glacier/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/muir_glacier/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.muir_glacier.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_muir_glacier_fork_types_imports_Root : IsImported globals "ethereum.muir_glacier.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/muir_glacier/utils/message.v b/CoqOfPython/ethereum/muir_glacier/utils/message.v index e7c7551..4f9fc3a 100644 --- a/CoqOfPython/ethereum/muir_glacier/utils/message.v +++ b/CoqOfPython/ethereum/muir_glacier/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.utils.message". +Definition globals : Globals.t := "ethereum.muir_glacier.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_muir_glacier_utils_address_imports_compute_contract_address : IsImported globals "ethereum.muir_glacier.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -85,10 +88,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -97,20 +100,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -124,7 +127,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -133,7 +136,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -142,10 +145,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -153,19 +156,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -174,14 +177,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -192,7 +195,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -204,7 +207,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/__init__.v b/CoqOfPython/ethereum/muir_glacier/vm/__init__.v index e34d6a5..937f07b 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/__init__.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.__init__". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -95,8 +97,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -109,30 +112,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -140,19 +143,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,8 +167,9 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -180,15 +184,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -201,8 +205,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -210,19 +214,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -238,7 +242,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/exceptions.v b/CoqOfPython/ethereum/muir_glacier/vm/exceptions.v index 9843a2b..7261cd7 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/exceptions.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.exceptions". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/gas.v b/CoqOfPython/ethereum/muir_glacier/vm/gas.v index 6ebc8c4..66a408e 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/gas.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.gas". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_muir_glacier_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 800 ], @@ -86,7 +88,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -116,7 +118,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -126,7 +128,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -136,7 +138,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -166,7 +168,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -176,7 +178,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -196,7 +198,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -206,7 +208,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -216,7 +218,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -226,7 +228,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -236,7 +238,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -246,7 +248,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -256,7 +258,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -266,7 +268,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -276,7 +278,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -286,7 +288,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -296,7 +298,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -306,7 +308,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -326,7 +328,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -336,7 +338,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -346,7 +348,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -356,7 +358,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -366,7 +368,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -376,7 +378,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -386,7 +388,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -396,7 +398,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -406,7 +408,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -416,7 +418,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -426,7 +428,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -436,7 +438,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -446,7 +448,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -456,7 +458,7 @@ Definition GAS_CODE_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -466,7 +468,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -495,8 +497,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -509,13 +512,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -526,22 +529,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -551,8 +554,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -572,9 +576,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -584,15 +588,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -601,16 +605,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -629,7 +634,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -639,7 +644,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -649,12 +654,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -664,14 +669,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -685,9 +690,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -695,20 +700,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -721,8 +726,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -736,16 +741,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -753,9 +758,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -764,13 +769,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -780,10 +785,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -791,8 +796,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -823,13 +829,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -837,32 +843,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -876,18 +882,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -898,15 +904,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -915,8 +921,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -932,9 +939,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/__init__.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/__init__.v index d7a2ea0..2e0d4f9 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/arithmetic.v index 6e651f5..e1e2fbf 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/bitwise.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/bitwise.v index 7fff3d6..218ede8 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/block.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/block.v index 167e4e0..3e5efa5 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/block.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.block". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,14 +350,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -361,21 +370,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -384,7 +393,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/comparison.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/comparison.v index 63bffa3..9c05bcd 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/control_flow.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/control_flow.v index 50f5c02..f7bab8a 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/environment.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/environment.v index dc3f915..e783002 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -78,8 +80,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -91,21 +94,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -114,14 +117,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -134,12 +138,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -148,42 +152,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -196,21 +201,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -219,14 +224,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -238,21 +244,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -261,14 +267,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -280,31 +287,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -318,30 +326,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -352,13 +360,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -367,14 +375,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -386,24 +395,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -415,14 +424,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -438,9 +448,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -448,9 +458,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -458,9 +468,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -469,12 +479,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -487,76 +497,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -568,24 +579,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -597,14 +608,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -620,9 +632,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -630,9 +642,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -640,9 +652,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -651,12 +663,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -669,76 +681,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -750,21 +763,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -773,14 +786,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -793,12 +807,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -807,26 +821,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -838,23 +852,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -867,12 +882,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -883,9 +898,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -893,9 +908,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -903,9 +918,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -914,12 +929,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -932,52 +947,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -985,34 +1000,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1023,24 +1039,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1052,14 +1068,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1071,9 +1088,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1081,9 +1098,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1091,9 +1108,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1102,12 +1119,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1120,108 +1137,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1232,12 +1250,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1246,20 +1264,20 @@ Definition extcodehash : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_CODE_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_CODE_HASH" |) ], make_dict [] |) in let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1268,15 +1286,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1289,12 +1307,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1305,23 +1323,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1333,35 +1352,35 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/keccak.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/keccak.v index a317bc4..3a872ed 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/log.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/log.v index 6d8d000..378ef42 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/log.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.log". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_pop : IsImported globals "ethereum.muir_glacier.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/memory.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/memory.v index c12ac45..deda339 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/stack.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/stack.v index c20b432..6b1c23c 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_muir_glacier_vm_memory_imports_buffer_read : IsImported globals "ethereum.muir_glacier.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/storage.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/storage.v index dd601c1..f8cea22 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -54,8 +56,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -70,9 +73,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -81,43 +84,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -131,9 +135,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -144,32 +148,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -177,11 +181,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -191,13 +195,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -207,21 +211,21 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -230,7 +234,7 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) |) in M.pure Constant.None_ )) |) in @@ -238,8 +242,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -248,18 +252,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -270,11 +274,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -289,12 +293,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -303,11 +307,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -321,8 +325,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -330,20 +334,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) |) ], make_dict [] @@ -354,13 +358,13 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) |) ], make_dict [] @@ -379,34 +383,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/instructions/system.v b/CoqOfPython/ethereum/muir_glacier/vm/instructions/system.v index 087a683..25f3e39 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/instructions/system.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.instructions.system". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,8 +107,9 @@ Axiom ethereum_muir_glacier_vm_stack_imports_push : IsImported globals "ethereum.muir_glacier.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in @@ -114,12 +117,12 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -129,32 +132,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -164,15 +167,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -188,10 +191,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -201,15 +204,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -230,29 +233,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -272,27 +275,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -300,10 +303,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -311,27 +314,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -344,25 +347,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -374,8 +377,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -387,9 +391,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,9 +401,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -407,9 +411,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -417,46 +421,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -465,26 +469,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -499,9 +504,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -509,9 +514,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -519,9 +524,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -530,9 +535,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -543,11 +548,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -557,12 +562,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -573,43 +578,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -618,26 +623,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -649,9 +655,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -659,9 +665,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -669,63 +675,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -733,24 +740,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -770,11 +777,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -782,10 +789,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -793,7 +800,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -801,10 +808,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -812,27 +819,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -845,23 +852,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -875,16 +882,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -896,14 +903,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -912,8 +919,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -925,12 +933,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -941,12 +949,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -957,9 +965,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,9 +975,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -977,9 +985,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -987,9 +995,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -997,9 +1005,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1007,12 +1015,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1024,15 +1032,15 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), ltac:(M.monadic ( M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) @@ -1041,7 +1049,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1049,7 +1057,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1057,13 +1065,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1071,56 +1079,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1129,25 +1137,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1156,17 +1164,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1176,32 +1184,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1209,14 +1217,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1228,12 +1237,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1244,12 +1253,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1260,9 +1269,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1270,9 +1279,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,9 +1289,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1290,9 +1299,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1300,26 +1309,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1330,13 +1339,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1344,58 +1353,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1404,17 +1413,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1424,32 +1433,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1457,14 +1466,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1476,12 +1486,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1491,27 +1501,27 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1524,7 +1534,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1533,33 +1543,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1571,15 +1581,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1587,28 +1597,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1616,33 +1626,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1652,9 +1662,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1662,19 +1672,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1684,15 +1694,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1704,12 +1715,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1720,12 +1731,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1736,9 +1747,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1746,9 +1757,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1756,9 +1767,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1766,9 +1777,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,12 +1787,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1790,76 +1801,77 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1871,12 +1883,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1887,12 +1899,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1903,9 +1915,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1913,9 +1925,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1923,9 +1935,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1933,9 +1945,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1943,12 +1955,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1957,82 +1969,83 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2044,9 +2057,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2054,9 +2067,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2064,54 +2077,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/interpreter.v b/CoqOfPython/ethereum/muir_glacier/vm/interpreter.v index 03f7f66..6f75fab 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/interpreter.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.interpreter". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -124,7 +126,7 @@ Axiom ethereum_muir_glacier_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -147,8 +149,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -170,9 +173,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -184,10 +187,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -195,44 +198,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -246,10 +249,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -262,10 +265,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -274,13 +277,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -290,12 +293,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -312,14 +315,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -327,7 +330,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -335,7 +338,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -347,22 +350,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -372,29 +375,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -402,8 +405,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -420,43 +424,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -464,24 +468,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -489,22 +493,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -524,13 +529,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -542,17 +547,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -560,10 +565,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -571,12 +576,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -588,10 +593,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -599,13 +604,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -613,22 +618,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -646,14 +652,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -661,13 +667,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/memory.v b/CoqOfPython/ethereum/muir_glacier/vm/memory.v index 2bdcef4..a751b41 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/memory.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.memory". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/__init__.v index 714a0bb..3ff4af1 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/alt_bn128.v index e709832..b97dd68 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_muir_glacier_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.muir_glacier.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/blake2f.v index 4a75fc0..2317e98 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_muir_glacier_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.muir_glacier.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ecrecover.v index 8312694..39ccd83 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_muir_glacier_vm_memory_imports_buffer_read : IsImported globals "ethereum.muir_glacier.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/identity.v index f2eb008..26780a0 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_muir_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.muir_glacier.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/mapping.v index e59e8d5..33837a2 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/modexp.v index adf5841..a5cd08f 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,7 +37,7 @@ Axiom ethereum_muir_glacier_vm_memory_imports_buffer_read : Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -44,34 +46,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -87,21 +90,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -117,21 +120,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -148,36 +151,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -192,7 +195,7 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "exp_length" |), + M.get_name (| globals, locals_stack, "exp_length" |), Constant.int 32 |), (* then *) @@ -200,15 +203,15 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -227,16 +230,16 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "adjusted_exp_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |), @@ -244,12 +247,12 @@ Definition modexp : Value.t -> Value.t -> M := |) |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ Constant.int 0; BinOp.sub (| M.call (| - M.get_field (| M.get_name (| globals, "exp_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exp_head" |), "bit_length" |), make_list [], make_dict [] |), @@ -266,22 +269,22 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.floor_div (| BinOp.mult (| M.call (| - M.get_name (| globals, "get_mult_complexity" |), + M.get_name (| globals, locals_stack, "get_mult_complexity" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -292,11 +295,11 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "adjusted_exp_length" |); + M.get_name (| globals, locals_stack, "adjusted_exp_length" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -306,7 +309,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |) |), - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) ], make_dict [] @@ -316,12 +319,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -329,9 +332,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -347,20 +350,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -371,14 +374,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -389,21 +392,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -415,39 +418,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -455,7 +458,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -466,8 +469,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_mult_complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing Karatsuba multiplication. " in @@ -475,14 +479,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 64 |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |) |) in @@ -493,7 +497,7 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 1024 |), (* then *) @@ -503,14 +507,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 4 |), BinOp.mult (| Constant.int 96, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 3072 @@ -524,14 +528,14 @@ Definition get_mult_complexity : Value.t -> Value.t -> M := BinOp.add (| BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 2 |), Constant.int 16 |), BinOp.mult (| Constant.int 480, - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) |) |), Constant.int 199680 diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ripemd160.v index d68f6cf..c989eeb 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_muir_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.muir_glacier.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/sha256.v index 778e74c..3d61480 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_muir_glacier_vm_gas_imports_charge_gas : IsImported globals "ethereum.muir_glacier.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/muir_glacier/vm/runtime.v b/CoqOfPython/ethereum/muir_glacier/vm/runtime.v index b541b08..604a265 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/runtime.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.runtime". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_muir_glacier_vm_instructions_imports_Ops : IsImported globals "ethereum.muir_glacier.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/muir_glacier/vm/stack.v b/CoqOfPython/ethereum/muir_glacier/vm/stack.v index 41a8707..39e785f 100644 --- a/CoqOfPython/ethereum/muir_glacier/vm/stack.v +++ b/CoqOfPython/ethereum/muir_glacier/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.muir_glacier.vm.stack". +Definition globals : Globals.t := "ethereum.muir_glacier.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_muir_glacier_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.muir_glacier.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/__init__.v b/CoqOfPython/ethereum/paris/__init__.v index fa10075..8e64af8 100644 --- a/CoqOfPython/ethereum/paris/__init__.v +++ b/CoqOfPython/ethereum/paris/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.__init__". +Definition globals : Globals.t := "ethereum.paris.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -17,7 +19,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 15537394 ], diff --git a/CoqOfPython/ethereum/paris/blocks.v b/CoqOfPython/ethereum/paris/blocks.v index 2aa7600..0b69d9c 100644 --- a/CoqOfPython/ethereum/paris/blocks.v +++ b/CoqOfPython/ethereum/paris/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.blocks". +Definition globals : Globals.t := "ethereum.paris.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/paris/bloom.v b/CoqOfPython/ethereum/paris/bloom.v index 6f6cc6b..8ed3f2c 100644 --- a/CoqOfPython/ethereum/paris/bloom.v +++ b/CoqOfPython/ethereum/paris/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.bloom". +Definition globals : Globals.t := "ethereum.paris.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_paris_fork_types_imports_Bloom : IsImported globals "ethereum.paris.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/fork.v b/CoqOfPython/ethereum/paris/fork.v index 442ce2d..8bef456 100644 --- a/CoqOfPython/ethereum/paris/fork.v +++ b/CoqOfPython/ethereum/paris/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.fork". +Definition globals : Globals.t := "ethereum.paris.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -155,10 +157,10 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -180,8 +182,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -201,13 +204,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -230,7 +234,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -241,9 +245,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -265,17 +269,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -288,13 +292,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -305,20 +309,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -343,113 +348,113 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "block" |), "ommers" |), + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |), make_tuple [ ] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "base_fee_per_gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "prev_randao" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "base_fee_per_gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "prev_randao" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -458,9 +463,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -469,9 +474,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -485,8 +490,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the base fee per gas for the block. @@ -509,22 +515,22 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_gas_target" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "ELASTICITY_MULTIPLIER" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "ELASTICITY_MULTIPLIER" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_name (| globals, "block_gas_limit" |); - M.get_name (| globals, "parent_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |); + M.get_name (| globals, locals_stack, "parent_gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -532,14 +538,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "expected_base_fee_per_gas" , - M.get_name (| globals, "parent_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |) |) in M.pure Constant.None_ (* else *) @@ -548,40 +554,40 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |); Constant.int 1 ], @@ -591,8 +597,8 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.add (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -601,36 +607,36 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_target" |), - M.get_name (| globals, "parent_gas_used" |) + M.get_name (| globals, locals_stack, "parent_gas_target" |), + M.get_name (| globals, locals_stack, "parent_gas_used" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.sub (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -639,9 +645,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "expected_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |) ], make_dict [] |) @@ -649,8 +655,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -669,124 +676,124 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |), - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , M.call (| - M.get_name (| globals, "calculate_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "calculate_base_fee_per_gas" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "base_fee_per_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "expected_base_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), Constant.int 0 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |), Constant.bytes "0000000000000000" |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -795,21 +802,22 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -837,23 +845,23 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -862,46 +870,46 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "priority_fee_per_gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) ], make_dict [] @@ -910,38 +918,39 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_price" , BinOp.add (| - M.get_name (| globals, "priority_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_price" , - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ] |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -965,7 +974,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -974,10 +983,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -987,9 +996,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1002,10 +1011,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1015,9 +1024,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1027,7 +1036,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -1046,8 +1055,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "prev_randao"; "transactions"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "prev_randao"; "transactions"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -1092,22 +1102,22 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1116,16 +1126,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1133,9 +1143,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1143,14 +1153,14 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ], M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "base_fee_per_gas" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -1158,18 +1168,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1177,49 +1187,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1230,44 +1240,44 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1278,8 +1288,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1307,30 +1318,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1339,10 +1350,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1351,8 +1362,8 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |) |) |) in M.pure Constant.None_ @@ -1361,100 +1372,100 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "max_gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "max_gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "effective_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "effective_gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -1462,7 +1473,7 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -1471,10 +1482,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -1482,25 +1493,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -1524,14 +1535,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1539,10 +1550,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1550,20 +1561,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 5 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1572,17 +1583,17 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "priority_fee_per_gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |), - M.get_field (| M.get_name (| globals, "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| @@ -1590,41 +1601,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_name (| globals, "priority_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1632,31 +1643,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1667,20 +1678,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1693,14 +1704,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1712,27 +1723,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1748,13 +1759,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1783,17 +1795,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1808,8 +1820,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1838,14 +1851,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -1853,7 +1866,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -1861,7 +1874,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -1875,9 +1888,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -1888,7 +1901,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -1907,10 +1920,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -1918,26 +1931,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -1953,17 +1966,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -1972,8 +1985,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -1996,47 +2010,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2044,10 +2058,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2055,19 +2069,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2077,18 +2091,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2100,58 +2114,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2168,10 +2182,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2180,15 +2194,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2203,10 +2217,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2215,15 +2229,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_1559" |), + M.get_name (| globals, locals_stack, "signing_hash_1559" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2242,13 +2256,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2263,8 +2277,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2280,12 +2295,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2296,8 +2311,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2315,19 +2331,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2343,8 +2359,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -2360,14 +2377,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2379,8 +2396,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_1559 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 1559 signature. @@ -2396,14 +2414,14 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2415,8 +2433,9 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2450,12 +2469,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2466,8 +2485,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2498,18 +2518,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2526,10 +2546,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2546,8 +2566,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( diff --git a/CoqOfPython/ethereum/paris/fork_types.v b/CoqOfPython/ethereum/paris/fork_types.v index a4242a8..b5a9c85 100644 --- a/CoqOfPython/ethereum/paris/fork_types.v +++ b/CoqOfPython/ethereum/paris/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.fork_types". +Definition globals : Globals.t := "ethereum.paris.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/paris/state.v b/CoqOfPython/ethereum/paris/state.v index a1eda52..b08baae 100644 --- a/CoqOfPython/ethereum/paris/state.v +++ b/CoqOfPython/ethereum/paris/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.state". +Definition globals : Globals.t := "ethereum.paris.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -85,21 +87,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -112,12 +116,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -127,8 +131,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -138,18 +143,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -161,8 +166,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -173,9 +179,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -183,11 +189,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -199,8 +205,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -223,10 +230,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -235,31 +242,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -279,22 +287,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -309,19 +318,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -337,18 +347,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -356,8 +366,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -372,14 +383,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -389,8 +400,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -408,17 +420,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -440,9 +453,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -451,14 +464,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -473,30 +486,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -514,10 +528,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -526,9 +540,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -537,7 +551,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -545,17 +559,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -563,11 +577,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -575,14 +589,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -592,8 +606,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -609,23 +624,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -635,15 +650,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -657,13 +673,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -671,8 +687,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -691,10 +708,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -704,8 +721,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -725,10 +743,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -736,9 +754,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -747,7 +765,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -756,8 +774,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -777,10 +796,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -788,9 +807,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -800,12 +819,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -816,8 +835,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -838,10 +858,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -849,15 +869,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -867,12 +887,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -885,8 +905,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -905,10 +926,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -917,7 +938,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -931,9 +952,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -943,12 +964,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -961,28 +982,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -992,36 +1014,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1038,19 +1062,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1066,21 +1091,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1092,8 +1117,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1107,19 +1133,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1136,19 +1163,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1167,14 +1195,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1187,18 +1215,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1207,7 +1235,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1215,7 +1243,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1228,10 +1256,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1239,14 +1267,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/transactions.v b/CoqOfPython/ethereum/paris/transactions.v index c466978..dd65a12 100644 --- a/CoqOfPython/ethereum/paris/transactions.v +++ b/CoqOfPython/ethereum/paris/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.transactions". +Definition globals : Globals.t := "ethereum.paris.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,14 +99,15 @@ Definition FeeMarketTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -112,17 +115,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -131,10 +134,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -144,9 +147,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -159,10 +162,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -172,9 +175,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -184,7 +187,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -199,8 +202,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -208,10 +212,10 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), @@ -222,7 +226,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 @@ -231,11 +235,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -252,7 +256,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 2 @@ -261,11 +265,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "FeeMarketTransaction" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -277,7 +281,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ @@ -286,7 +290,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/paris/trie.v b/CoqOfPython/ethereum/paris/trie.v index 90b1e2c..7f7d685 100644 --- a/CoqOfPython/ethereum/paris/trie.v +++ b/CoqOfPython/ethereum/paris/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.trie". +Definition globals : Globals.t := "ethereum.paris.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_paris_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,34 +124,34 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -187,14 +189,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -218,7 +221,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -234,10 +237,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -246,13 +249,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -261,10 +264,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -273,13 +276,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -288,10 +291,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -300,9 +303,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -310,7 +313,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -327,9 +330,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -339,9 +342,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -350,16 +353,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -369,8 +372,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -380,25 +384,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -410,10 +414,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -421,13 +425,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -442,27 +446,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -486,8 +490,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -504,14 +509,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -522,8 +527,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -543,8 +549,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -552,14 +558,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -571,18 +577,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -602,10 +609,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -613,21 +620,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -640,11 +648,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -652,12 +660,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -665,7 +673,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -680,9 +688,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -690,8 +698,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -728,7 +737,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -739,9 +748,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -752,13 +761,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -766,15 +775,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -784,20 +793,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -815,7 +824,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -823,13 +832,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -838,15 +847,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -856,20 +865,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -887,9 +896,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -897,8 +906,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -915,14 +925,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -933,26 +943,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -960,17 +970,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -982,9 +992,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -992,8 +1002,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1014,9 +1025,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1025,25 +1036,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1051,13 +1062,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1071,9 +1082,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1081,13 +1092,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1095,15 +1106,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1113,22 +1124,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1137,13 +1148,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1164,10 +1176,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1175,14 +1187,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1200,12 +1212,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1218,12 +1230,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1235,18 +1247,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1256,8 +1268,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1281,9 +1294,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1302,12 +1315,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1320,9 +1333,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1333,24 +1346,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1360,8 +1373,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1369,31 +1382,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1408,7 +1421,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1429,7 +1442,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1437,30 +1450,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1480,9 +1493,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1490,7 +1503,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1508,21 +1521,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1530,19 +1543,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1551,8 +1564,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1561,17 +1574,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1584,10 +1597,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/utils/__init__.v b/CoqOfPython/ethereum/paris/utils/__init__.v index afb5c35..21363a5 100644 --- a/CoqOfPython/ethereum/paris/utils/__init__.v +++ b/CoqOfPython/ethereum/paris/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.utils.__init__". +Definition globals : Globals.t := "ethereum.paris.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/paris/utils/address.v b/CoqOfPython/ethereum/paris/utils/address.v index bd0c332..c397529 100644 --- a/CoqOfPython/ethereum/paris/utils/address.v +++ b/CoqOfPython/ethereum/paris/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.utils.address". +Definition globals : Globals.t := "ethereum.paris.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_paris_fork_types_imports_Address : IsImported globals "ethereum.paris.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/utils/hexadecimal.v b/CoqOfPython/ethereum/paris/utils/hexadecimal.v index 62e084d..2d6e655 100644 --- a/CoqOfPython/ethereum/paris/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/paris/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.paris.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_paris_fork_types_imports_Root : IsImported globals "ethereum.paris.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/paris/utils/message.v b/CoqOfPython/ethereum/paris/utils/message.v index 9e2da6d..7260c46 100644 --- a/CoqOfPython/ethereum/paris/utils/message.v +++ b/CoqOfPython/ethereum/paris/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.utils.message". +Definition globals : Globals.t := "ethereum.paris.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_paris_utils_address_imports_compute_contract_address : IsImported globals "ethereum.paris.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/vm/__init__.v b/CoqOfPython/ethereum/paris/vm/__init__.v index 472ccd5..eb698f5 100644 --- a/CoqOfPython/ethereum/paris/vm/__init__.v +++ b/CoqOfPython/ethereum/paris/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.__init__". +Definition globals : Globals.t := "ethereum.paris.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,8 +99,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -111,30 +114,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -142,19 +145,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,24 +167,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -196,15 +200,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -217,8 +221,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -226,19 +230,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -254,7 +258,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/exceptions.v b/CoqOfPython/ethereum/paris/vm/exceptions.v index 95b6cd9..3b460e3 100644 --- a/CoqOfPython/ethereum/paris/vm/exceptions.v +++ b/CoqOfPython/ethereum/paris/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.exceptions". +Definition globals : Globals.t := "ethereum.paris.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/paris/vm/gas.v b/CoqOfPython/ethereum/paris/vm/gas.v index 7b37d78..a43a94d 100644 --- a/CoqOfPython/ethereum/paris/vm/gas.v +++ b/CoqOfPython/ethereum/paris/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.gas". +Definition globals : Globals.t := "ethereum.paris.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_paris_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -86,7 +88,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 4800 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -116,7 +118,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -126,7 +128,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -136,7 +138,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -166,7 +168,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -176,7 +178,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -196,7 +198,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -206,7 +208,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -216,7 +218,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -226,7 +228,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -236,7 +238,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -246,7 +248,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -256,7 +258,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -266,7 +268,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -276,7 +278,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -286,7 +288,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -296,7 +298,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -306,7 +308,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -326,7 +328,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -336,7 +338,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -346,7 +348,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -356,7 +358,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -366,7 +368,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -376,7 +378,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -386,7 +388,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -396,7 +398,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -406,7 +408,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -416,7 +418,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -426,7 +428,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -436,7 +438,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -465,8 +467,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -479,13 +482,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -496,22 +499,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -521,8 +524,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -542,9 +546,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -554,15 +558,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -571,16 +575,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,7 +614,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -619,12 +624,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -634,14 +639,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -655,9 +660,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -665,20 +670,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -691,8 +696,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -706,16 +711,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -723,9 +728,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -734,13 +739,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -750,10 +755,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -761,8 +766,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -793,13 +799,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -807,32 +813,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -846,18 +852,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -868,15 +874,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -885,8 +891,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -902,9 +909,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/paris/vm/instructions/__init__.v b/CoqOfPython/ethereum/paris/vm/instructions/__init__.v index 8cfce01..14189e3 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/paris/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/paris/vm/instructions/arithmetic.v index 3996ed7..bac5812 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/bitwise.v b/CoqOfPython/ethereum/paris/vm/instructions/bitwise.v index 68e07c4..929ae9e 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/block.v b/CoqOfPython/ethereum/paris/vm/instructions/block.v index 5869617..e351ba7 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/block.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.block". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -57,18 +60,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -77,14 +80,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -102,23 +105,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -127,14 +130,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -156,21 +160,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -179,14 +183,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -208,31 +213,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -253,21 +259,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -276,14 +282,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition prev_randao : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the `prev_randao` value onto the stack. @@ -304,21 +311,21 @@ Definition prev_randao : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "prev_randao" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "prev_randao" |) ], make_dict [] |) @@ -327,14 +334,15 @@ Definition prev_randao : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -355,21 +363,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -378,14 +386,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -403,21 +412,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -426,7 +435,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/comparison.v b/CoqOfPython/ethereum/paris/vm/instructions/comparison.v index f0bbc4a..6a1ee53 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/control_flow.v b/CoqOfPython/ethereum/paris/vm/instructions/control_flow.v index 077810e..d3d5774 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/environment.v b/CoqOfPython/ethereum/paris/vm/instructions/environment.v index 44987c3..fddea67 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -149,16 +153,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -166,17 +170,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -185,32 +189,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -223,21 +228,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -246,14 +251,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -265,21 +271,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -288,14 +294,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -307,31 +314,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -345,30 +353,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -379,13 +387,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -394,14 +402,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -413,24 +422,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -442,14 +451,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -465,9 +475,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -475,9 +485,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -485,9 +495,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -496,12 +506,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -514,76 +524,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -595,24 +606,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -624,14 +635,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -647,9 +659,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -657,9 +669,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -667,9 +679,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,12 +690,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -696,76 +708,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -777,21 +790,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -800,14 +813,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -820,12 +834,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -837,16 +851,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -854,17 +868,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -873,16 +887,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -894,23 +908,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -923,12 +938,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -939,9 +954,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -949,9 +964,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -959,9 +974,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -970,12 +985,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -988,18 +1003,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1009,21 +1024,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1032,22 +1047,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1056,19 +1071,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1076,34 +1091,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1114,24 +1130,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1143,14 +1159,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1162,9 +1179,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1172,9 +1189,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1182,9 +1199,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1193,12 +1210,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1211,108 +1228,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1323,12 +1341,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1340,16 +1358,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1357,17 +1375,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1376,10 +1394,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1388,15 +1406,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1409,12 +1427,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1425,23 +1443,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1453,42 +1472,43 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the base fee of the current block on to the stack. @@ -1500,21 +1520,21 @@ Definition base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "base_fee_per_gas" |) ], make_dict [] |) @@ -1523,7 +1543,7 @@ Definition base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/keccak.v b/CoqOfPython/ethereum/paris/vm/instructions/keccak.v index e935544..03d7f72 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/log.v b/CoqOfPython/ethereum/paris/vm/instructions/log.v index e38fab2..025ff79 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/log.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.log". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_paris_vm_stack_imports_pop : IsImported globals "ethereum.paris.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/vm/instructions/memory.v b/CoqOfPython/ethereum/paris/vm/instructions/memory.v index 211fafb..d54e1e1 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/stack.v b/CoqOfPython/ethereum/paris/vm/instructions/stack.v index 7c6a4bf..02d0f18 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_paris_vm_memory_imports_buffer_read : IsImported globals "ethereum.paris.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/vm/instructions/storage.v b/CoqOfPython/ethereum/paris/vm/instructions/storage.v index 760b3c6..0abe74e 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -59,8 +61,9 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -75,9 +78,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -89,16 +92,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -106,17 +109,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -125,33 +128,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -165,9 +169,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -178,32 +182,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -211,11 +215,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -223,7 +227,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -234,22 +238,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -261,13 +265,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -277,7 +281,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -285,7 +289,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -294,8 +298,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -306,7 +310,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -314,8 +318,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -324,18 +328,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -346,11 +350,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -365,12 +369,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -379,11 +383,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -397,8 +401,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -406,20 +410,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -430,16 +434,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -458,34 +462,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/instructions/system.v b/CoqOfPython/ethereum/paris/vm/instructions/system.v index 2ed4520..42d8e78 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/system.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.instructions.system". +Definition globals : Globals.t := "ethereum.paris.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -105,28 +107,29 @@ Axiom ethereum_paris_vm_stack_imports_push : IsImported globals "ethereum.paris.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -136,32 +139,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -171,15 +174,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -195,10 +198,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -208,15 +211,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -237,29 +240,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -279,27 +282,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -307,10 +310,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -318,27 +321,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,25 +354,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -381,8 +384,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -394,9 +398,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -404,9 +408,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -414,9 +418,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -424,46 +428,46 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -472,26 +476,27 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -506,9 +511,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -516,9 +521,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -526,9 +531,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -537,9 +542,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -550,11 +555,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -564,12 +569,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -580,43 +585,43 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -625,26 +630,27 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -656,9 +662,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -666,9 +672,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -676,63 +682,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -740,24 +747,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -777,11 +784,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -789,10 +796,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -800,7 +807,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -808,10 +815,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -819,27 +826,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -852,23 +859,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -882,16 +889,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -903,14 +910,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -919,8 +926,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -932,12 +940,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -948,12 +956,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -964,9 +972,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -974,9 +982,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -984,9 +992,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -994,9 +1002,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1004,9 +1012,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1014,12 +1022,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1029,28 +1037,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1060,16 +1068,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1077,7 +1085,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1085,7 +1093,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1093,13 +1101,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1107,56 +1115,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1165,25 +1173,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1192,17 +1200,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1212,32 +1220,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1245,14 +1253,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1264,12 +1273,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1280,12 +1289,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1296,9 +1305,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1306,9 +1315,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1316,9 +1325,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1326,9 +1335,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1336,26 +1345,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1365,28 +1374,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1395,13 +1404,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1409,58 +1418,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1469,17 +1478,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1489,32 +1498,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1522,14 +1531,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1541,12 +1551,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1556,28 +1566,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1589,20 +1599,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1615,7 +1625,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1623,32 +1633,32 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1656,33 +1666,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1692,9 +1702,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1702,19 +1712,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1724,15 +1734,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1744,12 +1755,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1760,12 +1771,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1776,9 +1787,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1786,9 +1797,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1796,9 +1807,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1806,9 +1817,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1816,12 +1827,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1831,104 +1842,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1940,12 +1952,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1956,12 +1968,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1972,9 +1984,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1982,9 +1994,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1992,9 +2004,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2002,9 +2014,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2012,12 +2024,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2027,110 +2039,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2142,9 +2155,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2152,9 +2165,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2162,54 +2175,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/interpreter.v b/CoqOfPython/ethereum/paris/vm/interpreter.v index ddfc003..57a5930 100644 --- a/CoqOfPython/ethereum/paris/vm/interpreter.v +++ b/CoqOfPython/ethereum/paris/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.interpreter". +Definition globals : Globals.t := "ethereum.paris.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -128,7 +130,7 @@ Axiom ethereum_paris_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -151,8 +153,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -174,9 +177,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -188,10 +191,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -199,44 +202,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -250,10 +253,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -266,10 +269,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -278,13 +281,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -294,12 +297,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -316,14 +319,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -331,7 +334,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -339,7 +342,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,22 +354,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -376,29 +379,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -406,8 +409,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -424,43 +428,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -468,24 +472,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -493,22 +497,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -528,13 +533,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -546,17 +551,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -564,10 +569,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -575,12 +580,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -592,10 +597,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -603,13 +608,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -617,22 +622,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -650,14 +656,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -665,13 +671,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/memory.v b/CoqOfPython/ethereum/paris/vm/memory.v index 0a1308d..5ebc425 100644 --- a/CoqOfPython/ethereum/paris/vm/memory.v +++ b/CoqOfPython/ethereum/paris/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.memory". +Definition globals : Globals.t := "ethereum.paris.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/__init__.v index 0726d50..8640d91 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/alt_bn128.v index 21ebabe..37c3636 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_paris_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.paris.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/blake2f.v index e4c8b13..a565bf1 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_paris_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.paris.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ecrecover.v index 62c83c2..4ff4a3c 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_paris_vm_memory_imports_buffer_read : IsImported globals "ethereum.paris.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/identity.v index 1936c37..fec619f 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_paris_vm_gas_imports_charge_gas : IsImported globals "ethereum.paris.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/mapping.v index eb81d35..01cefc2 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/modexp.v index 6904c05..b7ef5f2 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ripemd160.v index 5a9416e..b5edc19 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_paris_vm_gas_imports_charge_gas : IsImported globals "ethereum.paris.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/sha256.v index 882cecd..33c4215 100644 --- a/CoqOfPython/ethereum/paris/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/paris/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.paris.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_paris_vm_gas_imports_charge_gas : IsImported globals "ethereum.paris.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/paris/vm/runtime.v b/CoqOfPython/ethereum/paris/vm/runtime.v index 4733e48..d53167e 100644 --- a/CoqOfPython/ethereum/paris/vm/runtime.v +++ b/CoqOfPython/ethereum/paris/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.runtime". +Definition globals : Globals.t := "ethereum.paris.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_paris_vm_instructions_imports_Ops : IsImported globals "ethereum.paris.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/paris/vm/stack.v b/CoqOfPython/ethereum/paris/vm/stack.v index 026c5b4..fc25118 100644 --- a/CoqOfPython/ethereum/paris/vm/stack.v +++ b/CoqOfPython/ethereum/paris/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.paris.vm.stack". +Definition globals : Globals.t := "ethereum.paris.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_paris_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.paris.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/rlp.v b/CoqOfPython/ethereum/rlp.v index d513852..3a9bf15 100644 --- a/CoqOfPython/ethereum/rlp.v +++ b/CoqOfPython/ethereum/rlp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.rlp". +Definition globals : Globals.t := "ethereum.rlp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -70,12 +72,13 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition RLP : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Any" |) + M.get_name (| globals, locals_stack, "Any" |) )). Definition encode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes `raw_data` into a sequence of bytes using RLP. @@ -94,10 +97,10 @@ Definition encode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_data" |); - make_tuple [ M.get_name (| globals, "bytearray" |); M.get_name (| globals, "bytes" |) ] + M.get_name (| globals, locals_stack, "raw_data" |); + make_tuple [ M.get_name (| globals, locals_stack, "bytearray" |); M.get_name (| globals, locals_stack, "bytes" |) ] ], make_dict [] |), @@ -105,9 +108,9 @@ Definition encode : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_bytes" |), + M.get_name (| globals, locals_stack, "encode_bytes" |), make_list [ - M.get_name (| globals, "raw_data" |) + M.get_name (| globals, locals_stack, "raw_data" |) ], make_dict [] |) @@ -119,10 +122,10 @@ Definition encode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_data" |); - make_tuple [ M.get_name (| globals, "Uint" |); M.get_name (| globals, "FixedUint" |) ] + M.get_name (| globals, locals_stack, "raw_data" |); + make_tuple [ M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "FixedUint" |) ] ], make_dict [] |), @@ -130,10 +133,10 @@ Definition encode : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode" |), + M.get_name (| globals, locals_stack, "encode" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "raw_data" |), "to_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "raw_data" |), "to_be_bytes" |), make_list [], make_dict [] |) @@ -148,10 +151,10 @@ Definition encode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_data" |); - M.get_name (| globals, "str" |) + M.get_name (| globals, locals_stack, "raw_data" |); + M.get_name (| globals, locals_stack, "str" |) ], make_dict [] |), @@ -159,10 +162,10 @@ Definition encode : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_bytes" |), + M.get_name (| globals, locals_stack, "encode_bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "raw_data" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "raw_data" |), "encode" |), make_list [], make_dict [] |) @@ -177,10 +180,10 @@ Definition encode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_data" |); - M.get_name (| globals, "bool" |) + M.get_name (| globals, locals_stack, "raw_data" |); + M.get_name (| globals, locals_stack, "bool" |) ], make_dict [] |), @@ -189,12 +192,12 @@ Definition encode : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "raw_data" |), + M.get_name (| globals, locals_stack, "raw_data" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_bytes" |), + M.get_name (| globals, locals_stack, "encode_bytes" |), make_list [ Constant.bytes "01" ], @@ -206,7 +209,7 @@ Definition encode : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_bytes" |), + M.get_name (| globals, locals_stack, "encode_bytes" |), make_list [ Constant.bytes "" ], @@ -222,10 +225,10 @@ Definition encode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_data" |); - M.get_name (| globals, "Sequence" |) + M.get_name (| globals, locals_stack, "raw_data" |); + M.get_name (| globals, locals_stack, "Sequence" |) ], make_dict [] |), @@ -233,9 +236,9 @@ Definition encode : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_sequence" |), + M.get_name (| globals, locals_stack, "encode_sequence" |), make_list [ - M.get_name (| globals, "raw_data" |) + M.get_name (| globals, locals_stack, "raw_data" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition encode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "is_dataclass" |), + M.get_name (| globals, locals_stack, "is_dataclass" |), make_list [ - M.get_name (| globals, "raw_data" |) + M.get_name (| globals, locals_stack, "raw_data" |) ], make_dict [] |), @@ -257,12 +260,12 @@ Definition encode : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode" |), + M.get_name (| globals, locals_stack, "encode" |), make_list [ M.call (| - M.get_name (| globals, "astuple" |), + M.get_name (| globals, locals_stack, "astuple" |), make_list [ - M.get_name (| globals, "raw_data" |) + M.get_name (| globals, locals_stack, "raw_data" |) ], make_dict [] |) @@ -274,15 +277,15 @@ Definition encode : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "RLPEncodingError" |), + M.get_name (| globals, locals_stack, "RLPEncodingError" |), make_list [ M.call (| M.get_field (| Constant.str "RLP Encoding of type {} is not supported", "format" |), make_list [ M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ - M.get_name (| globals, "raw_data" |) + M.get_name (| globals, locals_stack, "raw_data" |) ], make_dict [] |) @@ -307,8 +310,9 @@ Definition encode : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes `raw_bytes`, a sequence of bytes, using RLP. @@ -325,12 +329,12 @@ Definition encode_bytes : Value.t -> Value.t -> M := let _ := M.assign_local (| "len_raw_data" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_bytes" |) + M.get_name (| globals, locals_stack, "raw_bytes" |) ], make_dict [] |) @@ -343,13 +347,13 @@ Definition encode_bytes : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "len_raw_data" |), + M.get_name (| globals, locals_stack, "len_raw_data" |), Constant.int 1 |), ltac:(M.monadic ( Compare.lt (| M.get_subscript (| - M.get_name (| globals, "raw_bytes" |), + M.get_name (| globals, locals_stack, "raw_bytes" |), Constant.int 0 |), Constant.int 128 @@ -359,7 +363,7 @@ Definition encode_bytes : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "raw_bytes" |) + M.get_name (| globals, locals_stack, "raw_bytes" |) |) in M.pure Constant.None_ (* else *) @@ -368,7 +372,7 @@ Definition encode_bytes : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "len_raw_data" |), + M.get_name (| globals, locals_stack, "len_raw_data" |), Constant.int 56 |), (* then *) @@ -376,18 +380,18 @@ Definition encode_bytes : Value.t -> Value.t -> M := let _ := M.return_ (| BinOp.add (| M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ make_list [ BinOp.add (| Constant.int 128, - M.get_name (| globals, "len_raw_data" |) + M.get_name (| globals, locals_stack, "len_raw_data" |) |) ] ], make_dict [] |), - M.get_name (| globals, "raw_bytes" |) + M.get_name (| globals, locals_stack, "raw_bytes" |) |) |) in M.pure Constant.None_ @@ -396,7 +400,7 @@ Definition encode_bytes : Value.t -> Value.t -> M := let _ := M.assign_local (| "len_raw_data_as_be" , M.call (| - M.get_field (| M.get_name (| globals, "len_raw_data" |), "to_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "len_raw_data" |), "to_be_bytes" |), make_list [], make_dict [] |) @@ -405,15 +409,15 @@ Definition encode_bytes : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ make_list [ BinOp.add (| Constant.int 183, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "len_raw_data_as_be" |) + M.get_name (| globals, locals_stack, "len_raw_data_as_be" |) ], make_dict [] |) @@ -422,9 +426,9 @@ Definition encode_bytes : Value.t -> Value.t -> M := ], make_dict [] |), - M.get_name (| globals, "len_raw_data_as_be" |) + M.get_name (| globals, locals_stack, "len_raw_data_as_be" |) |), - M.get_name (| globals, "raw_bytes" |) + M.get_name (| globals, locals_stack, "raw_bytes" |) |) |) in M.pure Constant.None_ @@ -434,8 +438,9 @@ Definition encode_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_sequence : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_sequence" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_sequence" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a list of RLP encodable objects (`raw_sequence`) using RLP. @@ -452,9 +457,9 @@ Definition encode_sequence : Value.t -> Value.t -> M := let _ := M.assign_local (| "joined_encodings" , M.call (| - M.get_name (| globals, "get_joined_encodings" |), + M.get_name (| globals, locals_stack, "get_joined_encodings" |), make_list [ - M.get_name (| globals, "raw_sequence" |) + M.get_name (| globals, locals_stack, "raw_sequence" |) ], make_dict [] |) @@ -462,12 +467,12 @@ Definition encode_sequence : Value.t -> Value.t -> M := let _ := M.assign_local (| "len_joined_encodings" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings" |) ], make_dict [] |) @@ -479,7 +484,7 @@ Definition encode_sequence : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "len_joined_encodings" |), + M.get_name (| globals, locals_stack, "len_joined_encodings" |), Constant.int 56 |), (* then *) @@ -487,18 +492,18 @@ Definition encode_sequence : Value.t -> Value.t -> M := let _ := M.return_ (| BinOp.add (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.add (| Constant.int 192, - M.get_name (| globals, "len_joined_encodings" |) + M.get_name (| globals, locals_stack, "len_joined_encodings" |) |) ] ], make_dict [] |), - M.get_name (| globals, "joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings" |) |) |) in M.pure Constant.None_ @@ -507,7 +512,7 @@ Definition encode_sequence : Value.t -> Value.t -> M := let _ := M.assign_local (| "len_joined_encodings_as_be" , M.call (| - M.get_field (| M.get_name (| globals, "len_joined_encodings" |), "to_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "len_joined_encodings" |), "to_be_bytes" |), make_list [], make_dict [] |) @@ -516,15 +521,15 @@ Definition encode_sequence : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.add (| Constant.int 247, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "len_joined_encodings_as_be" |) + M.get_name (| globals, locals_stack, "len_joined_encodings_as_be" |) ], make_dict [] |) @@ -533,9 +538,9 @@ Definition encode_sequence : Value.t -> Value.t -> M := ], make_dict [] |), - M.get_name (| globals, "len_joined_encodings_as_be" |) + M.get_name (| globals, locals_stack, "len_joined_encodings_as_be" |) |), - M.get_name (| globals, "joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings" |) |) |) in M.pure Constant.None_ @@ -543,8 +548,9 @@ Definition encode_sequence : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_joined_encodings : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_sequence" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_sequence" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain concatenation of rlp encoding for each item in the sequence raw_sequence. @@ -572,8 +578,9 @@ Definition get_joined_encodings : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "encoded_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "encoded_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Decodes an integer, byte sequence, or list of RLP encodable objects from the byte sequence `encoded_data`, using RLP. @@ -589,20 +596,20 @@ Definition decode : Value.t -> Value.t -> M := Object decoded from `encoded_data`. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |), Constant.int 0 |); M.call (| - M.get_name (| globals, "RLPDecodingError" |), + M.get_name (| globals, locals_stack, "RLPDecodingError" |), make_list [ Constant.str "Cannot decode empty bytestring" ], @@ -616,7 +623,7 @@ Definition decode : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt_e (| M.get_subscript (| - M.get_name (| globals, "encoded_data" |), + M.get_name (| globals, locals_stack, "encoded_data" |), Constant.int 0 |), Constant.int 191 @@ -625,9 +632,9 @@ Definition decode : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "decode_to_bytes" |), + M.get_name (| globals, locals_stack, "decode_to_bytes" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |) @@ -637,9 +644,9 @@ Definition decode : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "decode_to_sequence" |), + M.get_name (| globals, locals_stack, "decode_to_sequence" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |) @@ -650,7 +657,7 @@ Definition decode : Value.t -> Value.t -> M := Definition T : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "T" ], @@ -659,8 +666,9 @@ Definition T : Value.t := M.run ltac:(M.monadic ( )). Definition decode_to : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "encoded_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "encoded_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode the bytes in `encoded_data` to an object of type `cls`. `cls` can be a `Bytes` subclass, a dataclass, `Uint`, `U256` or `Tuple[cls]`. @@ -679,13 +687,13 @@ Definition decode_to : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); M.call (| - M.get_name (| globals, "decode" |), + M.get_name (| globals, locals_stack, "decode" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |) @@ -696,8 +704,9 @@ Definition decode_to : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _decode_to : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "cls"; "raw_rlp" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "cls"; "raw_rlp" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode the rlp structure in `encoded_data` to an object of type `cls`. `cls` can be a `Bytes` subclass, a dataclass, `Uint`, `U256`, @@ -720,15 +729,15 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ M.get_subscript (| - M.get_name (| globals, "Tuple" |), - make_tuple [ M.get_name (| globals, "Uint" |); Constant.ellipsis ] + M.get_name (| globals, locals_stack, "Tuple" |), + make_tuple [ M.get_name (| globals, locals_stack, "Uint" |); Constant.ellipsis ] |) ], make_dict [] @@ -738,7 +747,7 @@ Definition _decode_to : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "cls" |), "_name" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "_name" |), Constant.str "Tuple" |) )) @@ -746,17 +755,17 @@ Definition _decode_to : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "list" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "list" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in @@ -765,7 +774,7 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |), Constant.int 1 |), Constant.ellipsis @@ -778,20 +787,20 @@ Definition _decode_to : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "raw_item" |), - M.get_name (| globals, "raw_rlp" |), + M.get_name (| globals, locals_stack, "raw_item" |), + M.get_name (| globals, locals_stack, "raw_rlp" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "args" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "args" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |), Constant.int 0 |); - M.get_name (| globals, "raw_item" |) + M.get_name (| globals, locals_stack, "raw_item" |) ], make_dict [] |) @@ -806,9 +815,9 @@ Definition _decode_to : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ - M.get_name (| globals, "args" |) + M.get_name (| globals, locals_stack, "args" |) ], make_dict [] |) @@ -821,48 +830,48 @@ Definition _decode_to : Value.t -> Value.t -> M := make_list [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "t" |); M.get_name (| globals, "raw_item" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "t" |); M.get_name (| globals, locals_stack, "raw_item" |) ], M.call (| - M.get_name (| globals, "zip" |), + M.get_name (| globals, locals_stack, "zip" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |); - M.get_name (| globals, "raw_rlp" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |); + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "args" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "args" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ - M.get_name (| globals, "t" |); - M.get_name (| globals, "raw_item" |) + M.get_name (| globals, locals_stack, "t" |); + M.get_name (| globals, locals_stack, "raw_item" |) ], make_dict [] |) @@ -877,9 +886,9 @@ Definition _decode_to : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ - M.get_name (| globals, "args" |) + M.get_name (| globals, locals_stack, "args" |) ], make_dict [] |) @@ -893,26 +902,26 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Bytes0" |); M.get_name (| globals, "Bytes20" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Bytes0" |); M.get_name (| globals, locals_stack, "Bytes20" |) ] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in @@ -921,9 +930,9 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |), @@ -933,7 +942,7 @@ Definition _decode_to : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [], make_dict [] |) @@ -946,9 +955,9 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |), @@ -958,9 +967,9 @@ Definition _decode_to : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes20" |), + M.get_name (| globals, locals_stack, "Bytes20" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |) @@ -969,15 +978,15 @@ Definition _decode_to : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "RLPDecodingError" |), + M.get_name (| globals, locals_stack, "RLPDecodingError" |), make_list [ M.call (| M.get_field (| Constant.str "Bytes has length {}, expected 0 or 20", "format" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |) @@ -999,15 +1008,15 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ M.get_subscript (| - M.get_name (| globals, "List" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "List" |), + M.get_name (| globals, locals_stack, "Bytes" |) |) ], make_dict [] @@ -1017,7 +1026,7 @@ Definition _decode_to : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "cls" |), "_name" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "_name" |), Constant.str "List" |) )) @@ -1025,17 +1034,17 @@ Definition _decode_to : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "list" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "list" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in @@ -1045,20 +1054,20 @@ Definition _decode_to : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "raw_item" |), - M.get_name (| globals, "raw_rlp" |), + M.get_name (| globals, locals_stack, "raw_item" |), + M.get_name (| globals, locals_stack, "raw_rlp" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "items" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "items" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |), Constant.int 0 |); - M.get_name (| globals, "raw_item" |) + M.get_name (| globals, locals_stack, "raw_item" |) ], make_dict [] |) @@ -1072,7 +1081,7 @@ Definition _decode_to : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "items" |) + M.get_name (| globals, locals_stack, "items" |) |) in M.pure Constant.None_ (* else *) @@ -1082,17 +1091,17 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "cls" |); + M.get_name (| globals, locals_stack, "cls" |); M.call (| - M.get_name (| globals, "type" |), + M.get_name (| globals, locals_stack, "type" |), make_list [ M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "List" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| + M.get_name (| globals, locals_stack, "List" |), + M.get_name (| globals, locals_stack, "Bytes" |) |) ] |) ], @@ -1103,8 +1112,8 @@ Definition _decode_to : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "cls" |), "__origin__" |), - M.get_name (| globals, "Union" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__origin__" |), + M.get_name (| globals, locals_stack, "Union" |) |) )) |), @@ -1116,9 +1125,9 @@ Definition _decode_to : Value.t -> Value.t -> M := BoolOp.or (| Compare.not_eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |) ], make_dict [] |), @@ -1126,20 +1135,20 @@ Definition _decode_to : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_in (| - M.get_name (| globals, "Bytes" |), - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |) + M.get_name (| globals, locals_stack, "Bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |) |) )) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "RLPDecodingError" |), + M.get_name (| globals, locals_stack, "RLPDecodingError" |), make_list [ M.call (| M.get_field (| Constant.str "RLP Decoding to type {} is not supported", "format" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |) @@ -1155,17 +1164,17 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) |) in M.pure Constant.None_ (* else *) @@ -1175,22 +1184,22 @@ Definition _decode_to : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |), Constant.int 0 |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Bytes" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |), Constant.int 1 |); - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |) @@ -1200,13 +1209,13 @@ Definition _decode_to : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "cls" |), "__args__" |), + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "__args__" |), Constant.int 0 |); - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |) @@ -1222,10 +1231,10 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "issubclass" |), + M.get_name (| globals, locals_stack, "issubclass" |), make_list [ - M.get_name (| globals, "cls" |); - M.get_name (| globals, "bool" |) + M.get_name (| globals, locals_stack, "cls" |); + M.get_name (| globals, locals_stack, "bool" |) ], make_dict [] |), @@ -1235,14 +1244,14 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "raw_rlp" |), + M.get_name (| globals, locals_stack, "raw_rlp" |), Constant.bytes "01" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ Constant.bool true ], @@ -1256,14 +1265,14 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "raw_rlp" |), + M.get_name (| globals, locals_stack, "raw_rlp" |), Constant.bytes "" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ Constant.bool false ], @@ -1274,13 +1283,13 @@ Definition _decode_to : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "TypeError" |), + M.get_name (| globals, locals_stack, "TypeError" |), make_list [ M.call (| M.get_field (| Constant.str "Cannot decode {} as {}", "format" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |) @@ -1298,52 +1307,52 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "issubclass" |), + M.get_name (| globals, locals_stack, "issubclass" |), make_list [ - M.get_name (| globals, "cls" |); - M.get_name (| globals, "FixedBytes" |) + M.get_name (| globals, locals_stack, "cls" |); + M.get_name (| globals, locals_stack, "FixedBytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "cls" |), "LENGTH" |) + M.get_field (| M.get_name (| globals, locals_stack, "cls" |), "LENGTH" |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cls" |), + M.get_name (| globals, locals_stack, "cls" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |) @@ -1355,32 +1364,32 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "issubclass" |), + M.get_name (| globals, locals_stack, "issubclass" |), make_list [ - M.get_name (| globals, "cls" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "cls" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) |) in M.pure Constant.None_ (* else *) @@ -1389,27 +1398,27 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "issubclass" |), + M.get_name (| globals, locals_stack, "issubclass" |), make_list [ - M.get_name (| globals, "cls" |); - make_tuple [ M.get_name (| globals, "Uint" |); M.get_name (| globals, "FixedUint" |) ] + M.get_name (| globals, locals_stack, "cls" |); + make_tuple [ M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "FixedUint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in @@ -1421,34 +1430,34 @@ Definition _decode_to : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "is_dataclass" |), + M.get_name (| globals, locals_stack, "is_dataclass" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "list" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "list" |) ], make_dict [] |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "raw_rlp" |); - M.get_name (| globals, "list" |) + M.get_name (| globals, locals_stack, "raw_rlp" |); + M.get_name (| globals, locals_stack, "list" |) ], make_dict [] |) |) in @@ -1457,16 +1466,16 @@ Definition _decode_to : Value.t -> Value.t -> M := make_list [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "fields" |), + M.get_name (| globals, locals_stack, "fields" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |) @@ -1474,43 +1483,43 @@ Definition _decode_to : Value.t -> Value.t -> M := make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "field" |); M.get_name (| globals, "rlp_item" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "field" |); M.get_name (| globals, locals_stack, "rlp_item" |) ], M.call (| - M.get_name (| globals, "zip" |), + M.get_name (| globals, locals_stack, "zip" |), make_list [ M.call (| - M.get_name (| globals, "fields" |), + M.get_name (| globals, locals_stack, "fields" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |); - M.get_name (| globals, "raw_rlp" |) + M.get_name (| globals, locals_stack, "raw_rlp" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "args" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "args" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "_decode_to" |), + M.get_name (| globals, locals_stack, "_decode_to" |), make_list [ - M.get_field (| M.get_name (| globals, "field" |), "type" |); - M.get_name (| globals, "rlp_item" |) + M.get_field (| M.get_name (| globals, locals_stack, "field" |), "type" |); + M.get_name (| globals, locals_stack, "rlp_item" |) ], make_dict [] |) @@ -1525,12 +1534,12 @@ Definition _decode_to : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_name (| globals, "T" |); + M.get_name (| globals, locals_stack, "T" |); M.call (| - M.get_name (| globals, "cls" |), - M.get_name (| globals, "args" |), + M.get_name (| globals, locals_stack, "cls" |), + M.get_name (| globals, locals_stack, "args" |), make_dict [] |) ], @@ -1541,12 +1550,12 @@ Definition _decode_to : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "RLPDecodingError" |), + M.get_name (| globals, locals_stack, "RLPDecodingError" |), make_list [ M.call (| M.get_field (| Constant.str "RLP Decoding to type {} is not supported", "format" |), make_list [ - M.get_name (| globals, "cls" |) + M.get_name (| globals, locals_stack, "cls" |) ], make_dict [] |) @@ -1574,8 +1583,9 @@ Definition _decode_to : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_to_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "encoded_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "encoded_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Decodes a rlp encoded byte stream assuming that the decoded data should be of type `bytes`. @@ -1596,9 +1606,9 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := BoolOp.and (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_bytes" |) + M.get_name (| globals, locals_stack, "encoded_bytes" |) ], make_dict [] |), @@ -1607,7 +1617,7 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.lt (| M.get_subscript (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 0 |), Constant.int 128 @@ -1617,7 +1627,7 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "encoded_bytes" |) + M.get_name (| globals, locals_stack, "encoded_bytes" |) |) in M.pure Constant.None_ (* else *) @@ -1627,7 +1637,7 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt_e (| M.get_subscript (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 0 |), Constant.int 183 @@ -1638,65 +1648,65 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := "len_raw_data" , BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 0 |), Constant.int 128 |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "len_raw_data" |), + M.get_name (| globals, locals_stack, "len_raw_data" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_bytes" |) + M.get_name (| globals, locals_stack, "encoded_bytes" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "raw_data" , M.slice (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 1, BinOp.add (| Constant.int 1, - M.get_name (| globals, "len_raw_data" |) + M.get_name (| globals, locals_stack, "len_raw_data" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "len_raw_data" |), + M.get_name (| globals, locals_stack, "len_raw_data" |), Constant.int 1 |), ltac:(M.monadic ( Compare.lt (| M.get_subscript (| - M.get_name (| globals, "raw_data" |), + M.get_name (| globals, locals_stack, "raw_data" |), Constant.int 0 |), Constant.int 128 |) )) |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "raw_data" |) + M.get_name (| globals, locals_stack, "raw_data" |) |) in M.pure Constant.None_ (* else *) @@ -1707,7 +1717,7 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := BinOp.add (| Constant.int 1, M.get_subscript (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 0 |) |), @@ -1715,48 +1725,48 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| BinOp.sub (| - M.get_name (| globals, "decoded_data_start_idx" |), + M.get_name (| globals, locals_stack, "decoded_data_start_idx" |), Constant.int 1 |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_bytes" |) + M.get_name (| globals, locals_stack, "encoded_bytes" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 1 |), Constant.int 0 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "len_decoded_data" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), Constant.int 1, - M.get_name (| globals, "decoded_data_start_idx" |), + M.get_name (| globals, locals_stack, "decoded_data_start_idx" |), Constant.None_ |) ], @@ -1764,48 +1774,48 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_name (| globals, "len_decoded_data" |), + M.get_name (| globals, locals_stack, "len_decoded_data" |), Constant.int 56 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "decoded_data_end_idx" , BinOp.add (| - M.get_name (| globals, "decoded_data_start_idx" |), - M.get_name (| globals, "len_decoded_data" |) + M.get_name (| globals, locals_stack, "decoded_data_start_idx" |), + M.get_name (| globals, locals_stack, "len_decoded_data" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| BinOp.sub (| - M.get_name (| globals, "decoded_data_end_idx" |), + M.get_name (| globals, locals_stack, "decoded_data_end_idx" |), Constant.int 1 |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_bytes" |) + M.get_name (| globals, locals_stack, "encoded_bytes" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "encoded_bytes" |), - M.get_name (| globals, "decoded_data_start_idx" |), - M.get_name (| globals, "decoded_data_end_idx" |), + M.get_name (| globals, locals_stack, "encoded_bytes" |), + M.get_name (| globals, locals_stack, "decoded_data_start_idx" |), + M.get_name (| globals, locals_stack, "decoded_data_end_idx" |), Constant.None_ |) |) in @@ -1816,8 +1826,9 @@ Definition decode_to_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_to_sequence : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "encoded_sequence" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "encoded_sequence" ] in + ltac:(M.monadic ( let _ := Constant.str " Decodes a rlp encoded byte stream assuming that the decoded data should be of type `Sequence` of objects. @@ -1837,7 +1848,7 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt_e (| M.get_subscript (| - M.get_name (| globals, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), Constant.int 0 |), Constant.int 247 @@ -1848,37 +1859,37 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := "len_joined_encodings" , BinOp.sub (| M.get_subscript (| - M.get_name (| globals, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), Constant.int 0 |), Constant.int 192 |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "len_joined_encodings" |), + M.get_name (| globals, locals_stack, "len_joined_encodings" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_sequence" |) + M.get_name (| globals, locals_stack, "encoded_sequence" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "joined_encodings" , M.slice (| - M.get_name (| globals, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), Constant.int 1, BinOp.add (| Constant.int 1, - M.get_name (| globals, "len_joined_encodings" |) + M.get_name (| globals, locals_stack, "len_joined_encodings" |) |), Constant.None_ |) @@ -1892,7 +1903,7 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := BinOp.add (| Constant.int 1, M.get_subscript (| - M.get_name (| globals, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), Constant.int 0 |) |), @@ -1900,48 +1911,48 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| BinOp.sub (| - M.get_name (| globals, "joined_encodings_start_idx" |), + M.get_name (| globals, locals_stack, "joined_encodings_start_idx" |), Constant.int 1 |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_sequence" |) + M.get_name (| globals, locals_stack, "encoded_sequence" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), Constant.int 1 |), Constant.int 0 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "len_joined_encodings" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), Constant.int 1, - M.get_name (| globals, "joined_encodings_start_idx" |), + M.get_name (| globals, locals_stack, "joined_encodings_start_idx" |), Constant.None_ |) ], @@ -1949,49 +1960,49 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_name (| globals, "len_joined_encodings" |), + M.get_name (| globals, locals_stack, "len_joined_encodings" |), Constant.int 56 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "joined_encodings_end_idx" , BinOp.add (| - M.get_name (| globals, "joined_encodings_start_idx" |), - M.get_name (| globals, "len_joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings_start_idx" |), + M.get_name (| globals, locals_stack, "len_joined_encodings" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| BinOp.sub (| - M.get_name (| globals, "joined_encodings_end_idx" |), + M.get_name (| globals, locals_stack, "joined_encodings_end_idx" |), Constant.int 1 |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_sequence" |) + M.get_name (| globals, locals_stack, "encoded_sequence" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "joined_encodings" , M.slice (| - M.get_name (| globals, "encoded_sequence" |), - M.get_name (| globals, "joined_encodings_start_idx" |), - M.get_name (| globals, "joined_encodings_end_idx" |), + M.get_name (| globals, locals_stack, "encoded_sequence" |), + M.get_name (| globals, locals_stack, "joined_encodings_start_idx" |), + M.get_name (| globals, locals_stack, "joined_encodings_end_idx" |), Constant.None_ |) |) in @@ -1999,9 +2010,9 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "decode_joined_encodings" |), + M.get_name (| globals, locals_stack, "decode_joined_encodings" |), make_list [ - M.get_name (| globals, "joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings" |) ], make_dict [] |) @@ -2009,8 +2020,9 @@ Definition decode_to_sequence : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_joined_encodings : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "joined_encodings" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "joined_encodings" ] in + ltac:(M.monadic ( let _ := Constant.str " Decodes `joined_encodings`, which is a concatenation of RLP encoded objects. @@ -2036,11 +2048,11 @@ Definition decode_joined_encodings : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "item_start_idx" |), + M.get_name (| globals, locals_stack, "item_start_idx" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings" |) ], make_dict [] |) @@ -2049,11 +2061,11 @@ Definition decode_joined_encodings : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_item_length" , M.call (| - M.get_name (| globals, "decode_item_length" |), + M.get_name (| globals, locals_stack, "decode_item_length" |), make_list [ M.slice (| - M.get_name (| globals, "joined_encodings" |), - M.get_name (| globals, "item_start_idx" |), + M.get_name (| globals, locals_stack, "joined_encodings" |), + M.get_name (| globals, locals_stack, "item_start_idx" |), Constant.None_, Constant.None_ |) @@ -2062,47 +2074,47 @@ Definition decode_joined_encodings : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| BinOp.sub (| BinOp.add (| - M.get_name (| globals, "item_start_idx" |), - M.get_name (| globals, "encoded_item_length" |) + M.get_name (| globals, locals_stack, "item_start_idx" |), + M.get_name (| globals, locals_stack, "encoded_item_length" |) |), Constant.int 1 |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "joined_encodings" |) + M.get_name (| globals, locals_stack, "joined_encodings" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "encoded_item" , M.slice (| - M.get_name (| globals, "joined_encodings" |), - M.get_name (| globals, "item_start_idx" |), + M.get_name (| globals, locals_stack, "joined_encodings" |), + M.get_name (| globals, locals_stack, "item_start_idx" |), BinOp.add (| - M.get_name (| globals, "item_start_idx" |), - M.get_name (| globals, "encoded_item_length" |) + M.get_name (| globals, locals_stack, "item_start_idx" |), + M.get_name (| globals, locals_stack, "encoded_item_length" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "decoded_sequence" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "decoded_sequence" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "decode" |), + M.get_name (| globals, locals_stack, "decode" |), make_list [ - M.get_name (| globals, "encoded_item" |) + M.get_name (| globals, locals_stack, "encoded_item" |) ], make_dict [] |) @@ -2112,7 +2124,7 @@ Definition decode_joined_encodings : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "item_start_idx", - M.get_name (| globals, "encoded_item_length" |) + M.get_name (| globals, locals_stack, "encoded_item_length" |) |) in M.pure Constant.None_ )), @@ -2121,13 +2133,14 @@ Definition decode_joined_encodings : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "decoded_sequence" |) + M.get_name (| globals, locals_stack, "decoded_sequence" |) |) in M.pure Constant.None_)). Definition decode_item_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "encoded_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "encoded_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the length of the rlp encoding for the first object in the encoded sequence. @@ -2148,29 +2161,29 @@ Definition decode_item_length : Value.t -> Value.t -> M := rlp_length : `int` " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |), Constant.int 0 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "first_rlp_byte" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.get_subscript (| - M.get_name (| globals, "encoded_data" |), + M.get_name (| globals, locals_stack, "encoded_data" |), Constant.int 0 |) ], @@ -2180,7 +2193,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := let _ := M.assign_local (| "length_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2195,7 +2208,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 128 |), (* then *) @@ -2210,7 +2223,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 183 |), (* then *) @@ -2218,7 +2231,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := let _ := M.assign_local (| "decoded_data_length" , BinOp.sub (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 128 |) |) in @@ -2229,7 +2242,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 191 |), (* then *) @@ -2237,52 +2250,52 @@ Definition decode_item_length : Value.t -> Value.t -> M := let _ := M.assign_local (| "length_length" , BinOp.sub (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 183 |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "length_length" |), + M.get_name (| globals, locals_stack, "length_length" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "encoded_data" |), + M.get_name (| globals, locals_stack, "encoded_data" |), Constant.int 1 |), Constant.int 0 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "decoded_data_length" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "encoded_data" |), + M.get_name (| globals, locals_stack, "encoded_data" |), Constant.int 1, BinOp.add (| Constant.int 1, - M.get_name (| globals, "length_length" |) + M.get_name (| globals, locals_stack, "length_length" |) |), Constant.None_ |) @@ -2297,7 +2310,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 247 |), (* then *) @@ -2305,7 +2318,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := let _ := M.assign_local (| "decoded_data_length" , BinOp.sub (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 192 |) |) in @@ -2316,7 +2329,7 @@ Definition decode_item_length : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 255 |), (* then *) @@ -2324,52 +2337,52 @@ Definition decode_item_length : Value.t -> Value.t -> M := let _ := M.assign_local (| "length_length" , BinOp.sub (| - M.get_name (| globals, "first_rlp_byte" |), + M.get_name (| globals, locals_stack, "first_rlp_byte" |), Constant.int 247 |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "length_length" |), + M.get_name (| globals, locals_stack, "length_length" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded_data" |) + M.get_name (| globals, locals_stack, "encoded_data" |) ], make_dict [] |) |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "encoded_data" |), + M.get_name (| globals, locals_stack, "encoded_data" |), Constant.int 1 |), Constant.int 0 |); - M.get_name (| globals, "RLPDecodingError" |) + M.get_name (| globals, locals_stack, "RLPDecodingError" |) ], make_dict [] |) in let _ := M.assign_local (| "decoded_data_length" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "encoded_data" |), + M.get_name (| globals, locals_stack, "encoded_data" |), Constant.int 1, BinOp.add (| Constant.int 1, - M.get_name (| globals, "length_length" |) + M.get_name (| globals, locals_stack, "length_length" |) |), Constant.None_ |) @@ -2394,16 +2407,17 @@ Definition decode_item_length : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.int 1, - M.get_name (| globals, "length_length" |) + M.get_name (| globals, locals_stack, "length_length" |) |), - M.get_name (| globals, "decoded_data_length" |) + M.get_name (| globals, locals_stack, "decoded_data_length" |) |) |) in M.pure Constant.None_)). Definition rlp_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the keccak-256 hash of the rlp encoding of the passed in data. @@ -2419,12 +2433,12 @@ Definition rlp_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_name (| globals, "encode" |), + M.get_name (| globals, locals_stack, "encode" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/__init__.v b/CoqOfPython/ethereum/shanghai/__init__.v index c452ed3..fdd0093 100644 --- a/CoqOfPython/ethereum/shanghai/__init__.v +++ b/CoqOfPython/ethereum/shanghai/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.__init__". +Definition globals : Globals.t := "ethereum.shanghai.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -14,7 +16,7 @@ Axiom ethereum_fork_criteria_imports_ByTimestamp : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByTimestamp" |), + M.get_name (| globals, locals_stack, "ByTimestamp" |), make_list [ Constant.int 1681338455 ], diff --git a/CoqOfPython/ethereum/shanghai/blocks.v b/CoqOfPython/ethereum/shanghai/blocks.v index 3dccfcd..ae02dbc 100644 --- a/CoqOfPython/ethereum/shanghai/blocks.v +++ b/CoqOfPython/ethereum/shanghai/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.blocks". +Definition globals : Globals.t := "ethereum.shanghai.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/shanghai/bloom.v b/CoqOfPython/ethereum/shanghai/bloom.v index f6a336d..65cd312 100644 --- a/CoqOfPython/ethereum/shanghai/bloom.v +++ b/CoqOfPython/ethereum/shanghai/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.bloom". +Definition globals : Globals.t := "ethereum.shanghai.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_shanghai_fork_types_imports_Bloom : IsImported globals "ethereum.shanghai.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/fork.v b/CoqOfPython/ethereum/shanghai/fork.v index 1ec1953..1444e28 100644 --- a/CoqOfPython/ethereum/shanghai/fork.v +++ b/CoqOfPython/ethereum/shanghai/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.fork". +Definition globals : Globals.t := "ethereum.shanghai.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -164,10 +166,10 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition EMPTY_OMMER_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [] ], @@ -189,8 +191,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -210,13 +213,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -239,7 +243,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -250,9 +254,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -274,17 +278,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -297,13 +301,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -314,20 +318,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -352,125 +357,125 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "block" |), "ommers" |), + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |), make_tuple [ ] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "base_fee_per_gas" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "prev_randao" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |); - M.get_field (| M.get_name (| globals, "block" |), "withdrawals" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "base_fee_per_gas" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "prev_randao" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "withdrawals" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "withdrawals_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "withdrawals_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "withdrawals_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "withdrawals_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -479,9 +484,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -490,9 +495,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -506,8 +511,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_gas_limit"; "parent_gas_limit"; "parent_gas_used"; "parent_base_fee_per_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the base fee per gas for the block. @@ -530,22 +536,22 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_gas_target" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "ELASTICITY_MULTIPLIER" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "ELASTICITY_MULTIPLIER" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_name (| globals, "block_gas_limit" |); - M.get_name (| globals, "parent_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |); + M.get_name (| globals, locals_stack, "parent_gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -553,14 +559,14 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "expected_base_fee_per_gas" , - M.get_name (| globals, "parent_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |) |) in M.pure Constant.None_ (* else *) @@ -569,40 +575,40 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_used" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_gas_used" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |); Constant.int 1 ], @@ -612,8 +618,8 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.add (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -622,36 +628,36 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used_delta" , BinOp.sub (| - M.get_name (| globals, "parent_gas_target" |), - M.get_name (| globals, "parent_gas_used" |) + M.get_name (| globals, locals_stack, "parent_gas_target" |), + M.get_name (| globals, locals_stack, "parent_gas_used" |) |) |) in let _ := M.assign_local (| "parent_fee_gas_delta" , BinOp.mult (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "gas_used_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "gas_used_delta" |) |) |) in let _ := M.assign_local (| "target_fee_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_fee_gas_delta" |), - M.get_name (| globals, "parent_gas_target" |) + M.get_name (| globals, locals_stack, "parent_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "parent_gas_target" |) |) |) in let _ := M.assign_local (| "base_fee_per_gas_delta" , BinOp.floor_div (| - M.get_name (| globals, "target_fee_gas_delta" |), - M.get_name (| globals, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) + M.get_name (| globals, locals_stack, "target_fee_gas_delta" |), + M.get_name (| globals, locals_stack, "BASE_FEE_MAX_CHANGE_DENOMINATOR" |) |) |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , BinOp.sub (| - M.get_name (| globals, "parent_base_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas_delta" |) + M.get_name (| globals, locals_stack, "parent_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas_delta" |) |) |) in M.pure Constant.None_ @@ -660,9 +666,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "expected_base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |) ], make_dict [] |) @@ -670,8 +676,9 @@ Definition calculate_base_fee_per_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -690,124 +697,124 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |), - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "expected_base_fee_per_gas" , M.call (| - M.get_name (| globals, "calculate_base_fee_per_gas" |), + M.get_name (| globals, locals_stack, "calculate_base_fee_per_gas" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "base_fee_per_gas" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "expected_base_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "header" |), "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "expected_base_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), Constant.int 0 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |), Constant.bytes "0000000000000000" |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |), - M.get_name (| globals, "EMPTY_OMMER_HASH" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |), + M.get_name (| globals, locals_stack, "EMPTY_OMMER_HASH" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -816,21 +823,22 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "base_fee_per_gas"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -858,23 +866,23 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -883,46 +891,46 @@ Definition check_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "priority_fee_per_gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) ], make_dict [] @@ -931,38 +939,39 @@ Definition check_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "effective_gas_price" , BinOp.add (| - M.get_name (| globals, "priority_fee_per_gas" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |), - M.get_name (| globals, "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |), + M.get_name (| globals, locals_stack, "base_fee_per_gas" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_price" , - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ] |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "error"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "error"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -986,7 +995,7 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) @@ -995,10 +1004,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -1008,9 +1017,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1023,10 +1032,10 @@ Definition make_receipt : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1036,9 +1045,9 @@ Definition make_receipt : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) @@ -1048,7 +1057,7 @@ Definition make_receipt : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_ )) |) in @@ -1067,8 +1076,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "prev_randao"; "transactions"; "chain_id"; "withdrawals" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "base_fee_per_gas"; "block_gas_limit"; "block_time"; "prev_randao"; "transactions"; "chain_id"; "withdrawals" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -1115,7 +1125,7 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) @@ -1123,15 +1133,15 @@ Definition apply_body : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ M.call (| - M.get_name (| globals, "map" |), + M.get_name (| globals, locals_stack, "map" |), make_list [ - M.get_name (| globals, "decode_transaction" |); - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "decode_transaction" |); + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |) @@ -1140,16 +1150,16 @@ Definition apply_body : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1157,9 +1167,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_name (| globals, "encode_transaction" |), + M.get_name (| globals, locals_stack, "encode_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1167,14 +1177,14 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "sender_address" |); M.get_name (| globals, "effective_gas_price" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "sender_address" |); M.get_name (| globals, locals_stack, "effective_gas_price" |) ], M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "base_fee_per_gas" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "base_fee_per_gas" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -1182,18 +1192,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |); M.get_name (| globals, "error" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |); M.get_name (| globals, locals_stack, "error" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -1201,49 +1211,49 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "error" |); + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "error" |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1254,42 +1264,42 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "wd" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "wd" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "withdrawals" |) + M.get_name (| globals, locals_stack, "withdrawals" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "withdrawals_trie" |); + M.get_name (| globals, locals_stack, "withdrawals_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) @@ -1297,9 +1307,9 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "wd" |) + M.get_name (| globals, locals_stack, "wd" |) ], make_dict [] |) @@ -1307,10 +1317,10 @@ Definition apply_body : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "process_withdrawal" |), + M.get_name (| globals, locals_stack, "process_withdrawal" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "wd" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "wd" |) ], make_dict [] |) in @@ -1318,20 +1328,20 @@ Definition apply_body : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "wd" |), "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "wd" |), "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "wd" |), "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "wd" |), "address" |) ], make_dict [] |) in @@ -1348,35 +1358,35 @@ Definition apply_body : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "withdrawals_trie" |) + M.get_name (| globals, locals_stack, "withdrawals_trie" |) ], make_dict [] |) @@ -1387,8 +1397,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1416,30 +1427,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1448,10 +1459,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -1460,8 +1471,8 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |) |) |) in M.pure Constant.None_ @@ -1470,100 +1481,100 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "max_gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "max_gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "effective_gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "effective_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "effective_gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "preaccessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -1571,15 +1582,15 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "preaccessed_storage_keys" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1587,10 +1598,10 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -1598,25 +1609,25 @@ Definition process_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "keys" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "keys" |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "preaccessed_storage_keys" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "preaccessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_name (| globals, "address" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "address" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in @@ -1640,14 +1651,14 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1655,10 +1666,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1666,20 +1677,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 5 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1688,17 +1699,17 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |) |) |) in let _ := M.assign_local (| "priority_fee_per_gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "env" |), "gas_price" |), - M.get_field (| M.get_name (| globals, "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "gas_price" |), + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "base_fee_per_gas" |) |) |) in let _ := M.assign_local (| @@ -1706,41 +1717,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_name (| globals, "priority_fee_per_gas" |) + M.get_name (| globals, locals_stack, "priority_fee_per_gas" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1748,31 +1759,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1783,20 +1794,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1809,14 +1820,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1828,27 +1839,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1864,13 +1875,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |); M.get_field (| M.get_name (| globals, "output" |), "error" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "error" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1900,13 +1912,13 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), (* then *) ltac:(M.monadic ( @@ -1922,7 +1934,7 @@ Definition validate_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1946,9 +1958,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -1958,15 +1970,15 @@ Definition validate_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ], make_dict [] |), BinOp.mult (| Constant.int 2, - M.get_name (| globals, "MAX_CODE_SIZE" |) + M.get_name (| globals, locals_stack, "MAX_CODE_SIZE" |) |) |) )) @@ -1987,8 +1999,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -2017,14 +2030,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -2032,7 +2045,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -2040,7 +2053,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2054,9 +2067,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2068,20 +2081,20 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_cost" , BinOp.add (| - M.get_name (| globals, "TX_CREATE_COST" |), + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ M.call (| - M.get_name (| globals, "init_code_cost" |), + M.get_name (| globals, locals_stack, "init_code_cost" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "tx" |), "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ], make_dict [] |) @@ -2113,10 +2126,10 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - make_tuple [ M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "tx" |); + make_tuple [ M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] ], make_dict [] |), @@ -2124,26 +2137,26 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "_address" |); M.get_name (| globals, "keys" |) ], - M.get_field (| M.get_name (| globals, "tx" |), "access_list" |), + make_tuple [ M.get_name (| globals, locals_stack, "_address" |); M.get_name (| globals, locals_stack, "keys" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "access_list_cost", - M.get_name (| globals, "TX_ACCESS_LIST_ADDRESS_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_ADDRESS_COST" |) |) in let _ := M.assign_op_local (| BinOp.add, "access_list_cost", BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "keys" |) + M.get_name (| globals, locals_stack, "keys" |) ], make_dict [] |), - M.get_name (| globals, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) + M.get_name (| globals, locals_stack, "TX_ACCESS_LIST_STORAGE_KEY_COST" |) |) |) in M.pure Constant.None_ @@ -2159,17 +2172,17 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |), - M.get_name (| globals, "access_list_cost" |) + M.get_name (| globals, locals_stack, "access_list_cost" |) |) ], make_dict [] @@ -2178,8 +2191,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2202,47 +2216,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2250,10 +2264,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), @@ -2261,19 +2275,19 @@ Definition recover_sender : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "v" , - M.get_field (| M.get_name (| globals, "tx" |), "v" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2283,18 +2297,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2306,58 +2320,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2374,10 +2388,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -2386,15 +2400,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_2930" |), + M.get_name (| globals, locals_stack, "signing_hash_2930" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2409,10 +2423,10 @@ Definition recover_sender : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -2421,15 +2435,15 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); - M.get_field (| M.get_name (| globals, "tx" |), "y_parity" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "y_parity" |); M.call (| - M.get_name (| globals, "signing_hash_1559" |), + M.get_name (| globals, locals_stack, "signing_hash_1559" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2448,13 +2462,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2469,8 +2483,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2486,12 +2501,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2502,8 +2517,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2521,19 +2537,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2549,8 +2565,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_2930 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 2930 signature. @@ -2566,14 +2583,14 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2585,8 +2602,9 @@ Definition signing_hash_2930 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_1559 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 1559 signature. @@ -2602,14 +2620,14 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_field (| M.get_name (| globals, "tx" |), "access_list" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "chain_id" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_priority_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "max_fee_per_gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "access_list" |) ] ], make_dict [] |) @@ -2621,8 +2639,9 @@ Definition signing_hash_1559 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2656,12 +2675,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2672,8 +2691,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2704,18 +2724,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2732,10 +2752,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2752,8 +2772,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( diff --git a/CoqOfPython/ethereum/shanghai/fork_types.v b/CoqOfPython/ethereum/shanghai/fork_types.v index ce691e3..e9b6291 100644 --- a/CoqOfPython/ethereum/shanghai/fork_types.v +++ b/CoqOfPython/ethereum/shanghai/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.fork_types". +Definition globals : Globals.t := "ethereum.shanghai.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/shanghai/state.v b/CoqOfPython/ethereum/shanghai/state.v index 6c39384..18226ab 100644 --- a/CoqOfPython/ethereum/shanghai/state.v +++ b/CoqOfPython/ethereum/shanghai/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.state". +Definition globals : Globals.t := "ethereum.shanghai.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -88,21 +90,23 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -115,12 +119,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -130,8 +134,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -141,18 +146,18 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -164,8 +169,9 @@ Definition commit_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -176,9 +182,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -186,11 +192,11 @@ Definition rollback_transaction : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "clear" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "clear" |), make_list [], make_dict [] |) in @@ -202,8 +208,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -226,10 +233,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -238,31 +245,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -282,22 +290,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -312,19 +321,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -340,18 +350,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -359,8 +369,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -375,14 +386,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -392,8 +403,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition mark_account_created : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark an account as having been created in the current transaction. This information is used by `get_storage_original()` to handle an obscure @@ -411,17 +423,18 @@ Definition mark_account_created : Value.t -> Value.t -> M := Address of the account that has been created. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -443,9 +456,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -454,14 +467,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -476,30 +489,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -517,10 +531,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -529,9 +543,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -540,7 +554,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -548,17 +562,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -566,11 +580,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -578,14 +592,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -595,8 +609,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -612,23 +627,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -638,15 +653,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -660,13 +676,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -674,8 +690,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -694,10 +711,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -707,8 +724,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -728,10 +746,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -739,9 +757,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -750,7 +768,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -759,8 +777,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -780,10 +799,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -791,9 +810,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -803,12 +822,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -819,8 +838,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -841,10 +861,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -852,15 +872,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -870,12 +890,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -888,8 +908,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -908,10 +929,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -920,7 +941,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -934,9 +955,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -946,12 +967,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -964,28 +985,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -995,54 +1017,57 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition process_withdrawal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "wd" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "wd" ] in + ltac:(M.monadic ( let _ := Constant.str " Increase the balance of the withdrawing account. " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "wd" |), "address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "wd" |), "address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -1059,19 +1084,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1087,21 +1113,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1113,8 +1139,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1128,19 +1155,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1157,19 +1185,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition get_storage_original : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken @@ -1188,14 +1217,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_created_accounts" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_created_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1208,18 +1237,18 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "_" |); M.get_name (| globals, "original_trie" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "_" |); M.get_name (| globals, locals_stack, "original_trie" |) ], M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), Constant.int 0 |) |) in let _ := M.assign_local (| "original_account_trie" , M.call (| - M.get_field (| M.get_name (| globals, "original_trie" |), "get" |), + M.get_field (| M.get_name (| globals, locals_stack, "original_trie" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1228,7 +1257,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "original_account_trie" |), + M.get_name (| globals, locals_stack, "original_account_trie" |), Constant.None_ |), (* then *) @@ -1236,7 +1265,7 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1249,10 +1278,10 @@ Definition get_storage_original : Value.t -> Value.t -> M := let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "original_account_trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "original_account_trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -1260,14 +1289,14 @@ Definition get_storage_original : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "original_value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "original_value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "original_value" |) + M.get_name (| globals, locals_stack, "original_value" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/transactions.v b/CoqOfPython/ethereum/shanghai/transactions.v index 76f69cd..e7408ca 100644 --- a/CoqOfPython/ethereum/shanghai/transactions.v +++ b/CoqOfPython/ethereum/shanghai/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.transactions". +Definition globals : Globals.t := "ethereum.shanghai.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,14 +99,15 @@ Definition FeeMarketTransaction : Value.t := Definition Transaction : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "AccessListTransaction" |); M.get_name (| globals, "FeeMarketTransaction" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ] |) )). Definition encode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -112,17 +115,17 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "LegacyTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "LegacyTransaction" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ (* else *) @@ -131,10 +134,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "AccessListTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |) ], make_dict [] |), @@ -144,9 +147,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "01", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -159,10 +162,10 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "FeeMarketTransaction" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |) ], make_dict [] |), @@ -172,9 +175,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := BinOp.add (| Constant.bytes "02", M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -184,7 +187,7 @@ Definition encode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "Exception" |), + M.get_name (| globals, locals_stack, "Exception" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -199,8 +202,9 @@ Definition encode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition decode_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Decode a transaction. Needed because non-legacy transactions aren't RLP. " in @@ -208,10 +212,10 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), @@ -222,7 +226,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 1 @@ -231,11 +235,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "AccessListTransaction" |); + M.get_name (| globals, locals_stack, "AccessListTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -252,7 +256,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.get_subscript (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 0 |), Constant.int 2 @@ -261,11 +265,11 @@ Definition decode_transaction : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "decode_to" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "decode_to" |), make_list [ - M.get_name (| globals, "FeeMarketTransaction" |); + M.get_name (| globals, locals_stack, "FeeMarketTransaction" |); M.slice (| - M.get_name (| globals, "tx" |), + M.get_name (| globals, locals_stack, "tx" |), Constant.int 1, Constant.None_, Constant.None_ @@ -277,7 +281,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidBlock" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidBlock" |)) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ @@ -286,7 +290,7 @@ Definition decode_transaction : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) |) in M.pure Constant.None_ )) |) in diff --git a/CoqOfPython/ethereum/shanghai/trie.v b/CoqOfPython/ethereum/shanghai/trie.v index 3192625..2a44bc7 100644 --- a/CoqOfPython/ethereum/shanghai/trie.v +++ b/CoqOfPython/ethereum/shanghai/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.trie". +Definition globals : Globals.t := "ethereum.shanghai.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -91,10 +93,10 @@ Axiom ethereum_shanghai_transactions_imports_LegacyTransaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -107,14 +109,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); M.get_name (| globals, "Withdrawal" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); M.get_name (| globals, locals_stack, "Withdrawal" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -124,41 +126,41 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), + M.get_name (| globals, locals_stack, "Optional" |), M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Withdrawal" |); M.get_name (| globals, "Bytes" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Withdrawal" |); M.get_name (| globals, locals_stack, "Bytes" |) ] |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -196,14 +198,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -227,7 +230,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -243,10 +246,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -255,13 +258,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -270,10 +273,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -282,13 +285,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -297,10 +300,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -309,9 +312,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -319,7 +322,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -336,9 +339,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -348,9 +351,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -359,16 +362,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -378,8 +381,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -389,25 +393,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -419,10 +423,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "LegacyTransaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Withdrawal" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "LegacyTransaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Withdrawal" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -430,13 +434,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -451,27 +455,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -495,8 +499,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -513,14 +518,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -531,8 +536,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -552,8 +558,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -561,14 +567,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -580,18 +586,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -611,10 +618,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -622,21 +629,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -649,11 +657,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -661,12 +669,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -674,7 +682,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -689,9 +697,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -699,8 +707,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -737,7 +746,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -748,9 +757,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -761,13 +770,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -775,15 +784,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -793,20 +802,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -824,7 +833,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -832,13 +841,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -847,15 +856,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -865,20 +874,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -896,9 +905,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -906,8 +915,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -924,14 +934,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -942,26 +952,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -969,17 +979,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -991,9 +1001,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -1001,8 +1011,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1023,9 +1034,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1034,25 +1045,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1060,13 +1071,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1080,9 +1091,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1090,13 +1101,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1104,15 +1115,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1122,22 +1133,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1146,13 +1157,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1173,10 +1185,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1184,14 +1196,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1209,12 +1221,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1227,12 +1239,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1244,18 +1256,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1265,8 +1277,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1290,9 +1303,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1311,12 +1324,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1329,9 +1342,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1342,24 +1355,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1369,8 +1382,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1378,31 +1391,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1417,7 +1430,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1438,7 +1451,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1446,30 +1459,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1489,9 +1502,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1499,7 +1512,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1517,21 +1530,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1539,19 +1552,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1560,8 +1573,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1570,17 +1583,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1593,10 +1606,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/utils/__init__.v b/CoqOfPython/ethereum/shanghai/utils/__init__.v index 5a9b965..043dac7 100644 --- a/CoqOfPython/ethereum/shanghai/utils/__init__.v +++ b/CoqOfPython/ethereum/shanghai/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.utils.__init__". +Definition globals : Globals.t := "ethereum.shanghai.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/shanghai/utils/address.v b/CoqOfPython/ethereum/shanghai/utils/address.v index 309f4c7..d0b9263 100644 --- a/CoqOfPython/ethereum/shanghai/utils/address.v +++ b/CoqOfPython/ethereum/shanghai/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.utils.address". +Definition globals : Globals.t := "ethereum.shanghai.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -41,8 +43,9 @@ Axiom ethereum_shanghai_fork_types_imports_Address : IsImported globals "ethereum.shanghai.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -58,11 +61,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -77,8 +80,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -98,14 +102,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -117,7 +121,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -126,9 +130,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -136,9 +140,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) @@ -146,8 +150,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_create2_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "salt"; "call_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "salt"; "call_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created, which is based on the sender address, salt and the call data as well. @@ -172,14 +177,14 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := BinOp.add (| BinOp.add (| Constant.bytes "ff", - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "salt" |) + M.get_name (| globals, locals_stack, "salt" |) |), M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |) @@ -188,9 +193,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -198,7 +203,7 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -207,9 +212,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -217,9 +222,9 @@ Definition compute_create2_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/utils/hexadecimal.v b/CoqOfPython/ethereum/shanghai/utils/hexadecimal.v index d044fd0..460325a 100644 --- a/CoqOfPython/ethereum/shanghai/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/shanghai/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.shanghai.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_shanghai_fork_types_imports_Root : IsImported globals "ethereum.shanghai.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/shanghai/utils/message.v b/CoqOfPython/ethereum/shanghai/utils/message.v index d1e2dbc..918b127 100644 --- a/CoqOfPython/ethereum/shanghai/utils/message.v +++ b/CoqOfPython/ethereum/shanghai/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.utils.message". +Definition globals : Globals.t := "ethereum.shanghai.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -56,8 +58,9 @@ Axiom ethereum_shanghai_utils_address_imports_compute_contract_address : IsImported globals "ethereum.shanghai.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value"; "is_static"; "preaccessed_addresses"; "preaccessed_storage_keys" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -99,10 +102,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -111,20 +114,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -138,7 +141,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -147,7 +150,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -156,10 +159,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -167,19 +170,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -188,14 +191,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -206,7 +209,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -219,30 +222,30 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "accessed_addresses" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "current_target" |) + M.get_name (| globals, locals_stack, "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "caller" |) + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "PRE_COMPILED_CONTRACTS" |), "keys" |), + M.get_field (| M.get_name (| globals, locals_stack, "PRE_COMPILED_CONTRACTS" |), "keys" |), make_list [], make_dict [] |) @@ -250,15 +253,15 @@ Definition prepare_message : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "accessed_addresses" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "accessed_addresses" |), "update" |), make_list [ - M.get_name (| globals, "preaccessed_addresses" |) + M.get_name (| globals, locals_stack, "preaccessed_addresses" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/__init__.v b/CoqOfPython/ethereum/shanghai/vm/__init__.v index 1cfebb9..2c94399 100644 --- a/CoqOfPython/ethereum/shanghai/vm/__init__.v +++ b/CoqOfPython/ethereum/shanghai/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.__init__". +Definition globals : Globals.t := "ethereum.shanghai.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -97,8 +99,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -111,30 +114,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -142,19 +145,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -164,24 +167,25 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_addresses" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_addresses" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accessed_storage_keys" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accessed_storage_keys" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -196,15 +200,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -217,8 +221,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -226,19 +230,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -254,7 +258,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/exceptions.v b/CoqOfPython/ethereum/shanghai/vm/exceptions.v index b659bce..b62f125 100644 --- a/CoqOfPython/ethereum/shanghai/vm/exceptions.v +++ b/CoqOfPython/ethereum/shanghai/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.exceptions". +Definition globals : Globals.t := "ethereum.shanghai.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -79,22 +81,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/shanghai/vm/gas.v b/CoqOfPython/ethereum/shanghai/vm/gas.v index 3604b0f..4271a86 100644 --- a/CoqOfPython/ethereum/shanghai/vm/gas.v +++ b/CoqOfPython/ethereum/shanghai/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.gas". +Definition globals : Globals.t := "ethereum.shanghai.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_shanghai_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -86,7 +88,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 4800 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -116,7 +118,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -126,7 +128,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -136,7 +138,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -166,7 +168,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -176,7 +178,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -196,7 +198,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -206,7 +208,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -216,7 +218,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -226,7 +228,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -236,7 +238,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -246,7 +248,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -256,7 +258,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -266,7 +268,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -276,7 +278,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -286,7 +288,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -296,7 +298,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -306,7 +308,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -326,7 +328,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -336,7 +338,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -346,7 +348,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -356,7 +358,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -366,7 +368,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -376,7 +378,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -386,7 +388,7 @@ Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -396,7 +398,7 @@ Definition GAS_RETURN_DATA_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -406,7 +408,7 @@ Definition GAS_FAST_STEP : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -416,7 +418,7 @@ Definition GAS_BLAKE2_PER_ROUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2100 ], @@ -426,7 +428,7 @@ Definition GAS_COLD_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2600 ], @@ -436,7 +438,7 @@ Definition GAS_COLD_ACCOUNT_ACCESS : Value.t := M.run ltac:(M.monadic ( Definition GAS_WARM_ACCESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 100 ], @@ -469,8 +471,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -483,13 +486,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -500,22 +503,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -525,8 +528,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -546,9 +550,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -558,15 +562,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -575,16 +579,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -603,7 +608,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -613,7 +618,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -623,12 +628,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -638,14 +643,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -659,9 +664,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -669,20 +674,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -695,8 +700,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -710,16 +715,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -727,9 +732,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -738,13 +743,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -754,10 +759,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -765,8 +770,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -797,13 +803,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -811,32 +817,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -850,18 +856,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -872,15 +878,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -889,8 +895,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -906,9 +913,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) @@ -916,8 +923,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition init_code_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "init_code_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "init_code_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas to be charged for the init code in CREAT* opcodes as well as create transactions. @@ -936,11 +944,11 @@ Definition init_code_cost : Value.t -> Value.t -> M := let _ := M.return_ (| BinOp.floor_div (| BinOp.mult (| - M.get_name (| globals, "GAS_INIT_CODE_WORD_COST" |), + M.get_name (| globals, locals_stack, "GAS_INIT_CODE_WORD_COST" |), M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "init_code_length" |) + M.get_name (| globals, locals_stack, "init_code_length" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/__init__.v b/CoqOfPython/ethereum/shanghai/vm/instructions/__init__.v index bf085c7..3e8b12d 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/shanghai/vm/instructions/arithmetic.v index d62c2ed..87c5f1b 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/bitwise.v b/CoqOfPython/ethereum/shanghai/vm/instructions/bitwise.v index 5e49a28..30a1e49 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -51,9 +54,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -61,42 +64,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -110,9 +114,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -120,42 +124,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -169,9 +174,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,42 +184,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -228,39 +234,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -275,9 +282,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -285,18 +292,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -304,7 +311,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -312,7 +319,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -326,15 +333,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -342,16 +349,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -359,23 +366,24 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shl : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift left (SHL) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -387,9 +395,9 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -397,18 +405,18 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -416,7 +424,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -424,14 +432,14 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.l_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |), - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) |) ], make_dict [] @@ -443,7 +451,7 @@ Definition bitwise_shl : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -453,23 +461,24 @@ Definition bitwise_shl : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_shr : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Logical shift right (SHR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -481,9 +490,9 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -491,18 +500,18 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -510,7 +519,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -518,8 +527,8 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.r_shift (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "shift" |) |) |) in M.pure Constant.None_ @@ -528,7 +537,7 @@ Definition bitwise_shr : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -538,23 +547,24 @@ Definition bitwise_shr : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_sar : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Arithmetic shift right (SAR) operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -566,9 +576,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "shift" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -577,9 +587,9 @@ Definition bitwise_sar : Value.t -> Value.t -> M := "signed_value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -588,10 +598,10 @@ Definition bitwise_sar : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -599,7 +609,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "shift" |), + M.get_name (| globals, locals_stack, "shift" |), Constant.int 256 |), (* then *) @@ -607,11 +617,11 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ BinOp.r_shift (| - M.get_name (| globals, "signed_value" |), - M.get_name (| globals, "shift" |) + M.get_name (| globals, locals_stack, "signed_value" |), + M.get_name (| globals, locals_stack, "shift" |) |) ], make_dict [] @@ -624,7 +634,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "signed_value" |), + M.get_name (| globals, locals_stack, "signed_value" |), Constant.int 0 |), (* then *) @@ -632,7 +642,7 @@ Definition bitwise_sar : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -644,23 +654,23 @@ Definition bitwise_sar : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_field (| M.get_name (| globals, "U256" |), "MAX_VALUE" |) + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "MAX_VALUE" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/block.v b/CoqOfPython/ethereum/shanghai/vm/instructions/block.v index 72e72da..cd0188d 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/block.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.block". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -57,18 +60,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -77,14 +80,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -102,23 +105,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -127,14 +130,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -156,21 +160,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -179,14 +183,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -208,31 +213,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -253,21 +259,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -276,14 +282,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition prev_randao : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the `prev_randao` value onto the stack. @@ -304,21 +311,21 @@ Definition prev_randao : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "prev_randao" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "prev_randao" |) ], make_dict [] |) @@ -327,14 +334,15 @@ Definition prev_randao : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -355,21 +363,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -378,14 +386,15 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition chain_id : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the chain id onto the stack. @@ -403,21 +412,21 @@ Definition chain_id : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "chain_id" |) ], make_dict [] |) @@ -426,7 +435,7 @@ Definition chain_id : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/comparison.v b/CoqOfPython/ethereum/shanghai/vm/instructions/comparison.v index 53c9557..121bfa8 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/control_flow.v b/CoqOfPython/ethereum/shanghai/vm/instructions/control_flow.v index e43ea45..1cf5348 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/environment.v b/CoqOfPython/ethereum/shanghai/vm/instructions/environment.v index 17798fb..a745422 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -76,8 +78,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -89,21 +92,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -112,14 +115,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -132,12 +136,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -149,16 +153,16 @@ Definition balance : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -166,17 +170,17 @@ Definition balance : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -185,32 +189,33 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -223,21 +228,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -246,14 +251,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -265,21 +271,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -288,14 +294,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -307,31 +314,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -345,30 +353,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -379,13 +387,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -394,14 +402,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -413,24 +422,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -442,14 +451,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -465,9 +475,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -475,9 +485,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -485,9 +495,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -496,12 +506,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -514,76 +524,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -595,24 +606,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -624,14 +635,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -647,9 +659,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -657,9 +669,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -667,9 +679,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -678,12 +690,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -696,76 +708,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -777,21 +790,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -800,14 +813,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -820,12 +834,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -837,16 +851,16 @@ Definition extcodesize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -854,17 +868,17 @@ Definition extcodesize : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -873,16 +887,16 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -894,23 +908,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -923,12 +938,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -939,9 +954,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -949,9 +964,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -959,9 +974,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -970,12 +985,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -988,18 +1003,18 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] @@ -1009,21 +1024,21 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_WARM_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1032,22 +1047,22 @@ Definition extcodecopy : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -1056,19 +1071,19 @@ Definition extcodecopy : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -1076,34 +1091,35 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the size of the return data buffer onto the stack. @@ -1114,24 +1130,24 @@ Definition returndatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) @@ -1143,14 +1159,15 @@ Definition returndatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition returndatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copies data from the return data buffer code to memory @@ -1162,9 +1179,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1172,9 +1189,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "return_data_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1182,9 +1199,9 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1193,12 +1210,12 @@ Definition returndatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -1211,108 +1228,109 @@ Definition returndatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_RETURN_DATA_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_RETURN_DATA_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "return_data_start_position" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |) ], make_dict [] |) |); - M.get_name (| globals, "OutOfBoundsRead" |) + M.get_name (| globals, locals_stack, "OutOfBoundsRead" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.slice (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_name (| globals, "return_data_start_position" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_name (| globals, locals_stack, "return_data_start_position" |), BinOp.add (| - M.get_name (| globals, "return_data_start_position" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "return_data_start_position" |), + M.get_name (| globals, locals_stack, "size" |) |), Constant.None_ |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodehash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Returns the keccak256 hash of a contract’s bytecode Parameters @@ -1323,12 +1341,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1340,16 +1358,16 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -1357,17 +1375,17 @@ Definition extcodehash : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) ], make_dict [] |) in @@ -1376,10 +1394,10 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1388,15 +1406,15 @@ Definition extcodehash : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "account" |), - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "account" |), + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "codehash" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1409,12 +1427,12 @@ Definition extcodehash : Value.t -> Value.t -> M := let _ := M.assign_local (| "codehash" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "account" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |) ], make_dict [] |) @@ -1425,23 +1443,24 @@ Definition extcodehash : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codehash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codehash" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition self_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the current address to the stack. @@ -1453,42 +1472,43 @@ Definition self_balance : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_FAST_STEP" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_FAST_STEP" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition base_fee : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the base fee of the current block on to the stack. @@ -1500,21 +1520,21 @@ Definition base_fee : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "base_fee_per_gas" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "base_fee_per_gas" |) ], make_dict [] |) @@ -1523,7 +1543,7 @@ Definition base_fee : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/keccak.v b/CoqOfPython/ethereum/shanghai/vm/instructions/keccak.v index 1565118..70897e7 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/log.v b/CoqOfPython/ethereum/shanghai/vm/instructions/log.v index b7f272a..4d0abf6 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/log.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.log". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -53,8 +55,9 @@ Axiom ethereum_shanghai_vm_stack_imports_pop : IsImported globals "ethereum.shanghai.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -72,9 +75,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -82,9 +85,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -95,11 +98,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -108,9 +111,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -119,9 +122,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -134,82 +137,82 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -217,9 +220,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -227,9 +230,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -237,9 +240,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -247,9 +250,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/memory.v b/CoqOfPython/ethereum/shanghai/vm/instructions/memory.v index f71e369..f195df9 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/stack.v b/CoqOfPython/ethereum/shanghai/vm/instructions/stack.v index 8c4b767..e18a708 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_shanghai_vm_memory_imports_buffer_read : IsImported globals "ethereum.shanghai.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. Push zero if num_bytes is zero. @@ -100,16 +104,16 @@ Definition push_n : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "num_bytes" |), + M.get_name (| globals, locals_stack, "num_bytes" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in @@ -117,10 +121,10 @@ Definition push_n : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -129,26 +133,26 @@ Definition push_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -160,26 +164,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -195,67 +200,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -275,64 +281,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -340,9 +346,9 @@ Definition push0 : Value.t := M.run ltac:(M.monadic ( Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -350,9 +356,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -360,9 +366,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -370,9 +376,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -380,9 +386,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -390,9 +396,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -400,9 +406,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -410,9 +416,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -420,9 +426,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -430,9 +436,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -440,9 +446,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -450,9 +456,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -460,9 +466,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -470,9 +476,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -480,9 +486,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -490,9 +496,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -500,9 +506,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -510,9 +516,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -520,9 +526,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -530,9 +536,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -540,9 +546,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -550,9 +556,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -560,9 +566,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -570,9 +576,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -580,9 +586,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -590,9 +596,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -600,9 +606,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -610,9 +616,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -620,9 +626,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -630,9 +636,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -640,9 +646,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -650,9 +656,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -660,9 +666,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -670,9 +676,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -680,9 +686,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -690,9 +696,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -700,9 +706,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -710,9 +716,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -720,9 +726,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -730,9 +736,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -740,9 +746,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -750,9 +756,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -760,9 +766,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -770,9 +776,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -780,9 +786,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -790,9 +796,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -800,9 +806,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -810,9 +816,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -820,9 +826,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -830,9 +836,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -840,9 +846,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -850,9 +856,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -860,9 +866,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -870,9 +876,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -880,9 +886,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -890,9 +896,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -900,9 +906,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -910,9 +916,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -920,9 +926,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -930,9 +936,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -940,9 +946,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -950,9 +956,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -960,9 +966,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -970,9 +976,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/storage.v b/CoqOfPython/ethereum/shanghai/vm/instructions/storage.v index a05890f..0e9b0a7 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -59,8 +61,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -75,9 +78,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -89,16 +92,16 @@ Definition sload : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) ], make_dict [] |) in @@ -106,17 +109,17 @@ Definition sload : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) ], make_dict [] |) in @@ -125,33 +128,34 @@ Definition sload : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -165,9 +169,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -178,32 +182,32 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "GAS_CALL_STIPEND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "GAS_CALL_STIPEND" |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.assign_local (| "original_value" , M.call (| - M.get_name (| globals, "get_storage_original" |), + M.get_name (| globals, locals_stack, "get_storage_original" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -211,11 +215,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -223,7 +227,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_cost" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -234,22 +238,22 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ], - M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |) + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ], + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_storage_keys" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_storage_keys" |), "add" |), make_list [ - make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); M.get_name (| globals, "key" |) ] + make_tuple [ M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_name (| globals, locals_stack, "key" |) ] ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) in M.pure Constant.None_ (* else *) @@ -261,13 +265,13 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "current_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "current_value" |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |) )) |), @@ -277,7 +281,7 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) @@ -285,7 +289,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) @@ -294,8 +298,8 @@ Definition sstore : Value.t -> Value.t -> M := BinOp.add, "gas_cost", BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |) |) in M.pure Constant.None_ @@ -306,7 +310,7 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -314,8 +318,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "current_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -324,18 +328,18 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |) )) @@ -346,11 +350,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -365,12 +369,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -379,11 +383,11 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) ], make_dict [] |) @@ -397,8 +401,8 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), - M.get_name (| globals, "new_value" |) + M.get_name (| globals, locals_stack, "original_value" |), + M.get_name (| globals, locals_stack, "new_value" |) |), (* then *) ltac:(M.monadic ( @@ -406,20 +410,20 @@ Definition sstore : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "original_value" |), + M.get_name (| globals, locals_stack, "original_value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_SET" |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |), + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -430,16 +434,16 @@ Definition sstore : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "GAS_STORAGE_UPDATE" |), - M.get_name (| globals, "GAS_COLD_SLOAD" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |), + M.get_name (| globals, locals_stack, "GAS_COLD_SLOAD" |) |), - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) ], make_dict [] @@ -458,34 +462,34 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/instructions/system.v b/CoqOfPython/ethereum/shanghai/vm/instructions/system.v index 4fc7b71..82dbbcc 100644 --- a/CoqOfPython/ethereum/shanghai/vm/instructions/system.v +++ b/CoqOfPython/ethereum/shanghai/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.instructions.system". +Definition globals : Globals.t := "ethereum.shanghai.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -109,8 +111,9 @@ Axiom ethereum_shanghai_vm_stack_imports_push : IsImported globals "ethereum.shanghai.vm.stack" "push". Definition generic_create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size"; "init_code_gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "endowment"; "contract_address"; "memory_start_position"; "memory_size"; "init_code_gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Core logic used by the `CREATE*` family of opcodes. " in @@ -118,51 +121,51 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "call_data" |) + M.get_name (| globals, locals_stack, "call_data" |) ], make_dict [] |), BinOp.mult (| Constant.int 2, - M.get_name (| globals, "MAX_CODE_SIZE" |) + M.get_name (| globals, locals_stack, "MAX_CODE_SIZE" |) |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "contract_address" |) + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |) in let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -172,32 +175,32 @@ Definition generic_create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -207,15 +210,15 @@ Definition generic_create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -231,10 +234,10 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -244,15 +247,15 @@ Definition generic_create : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -273,29 +276,29 @@ Definition generic_create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -313,17 +316,17 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -331,10 +334,10 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -342,27 +345,27 @@ Definition generic_create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -375,25 +378,25 @@ Definition generic_create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -405,8 +408,9 @@ Definition generic_create : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -418,9 +422,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -428,9 +432,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -438,9 +442,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -448,11 +452,11 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -461,12 +465,12 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "init_code_gas" , M.call (| - M.get_name (| globals, "init_code_cost" |), + M.get_name (| globals, locals_stack, "init_code_cost" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -475,38 +479,38 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |), - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "init_code_gas" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -515,27 +519,28 @@ Definition create : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |); - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |); + M.get_name (| globals, locals_stack, "init_code_gas" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition create2 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -550,9 +555,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -560,9 +565,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -570,9 +575,9 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -581,9 +586,9 @@ Definition create2 : Value.t -> Value.t -> M := "salt" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -594,11 +599,11 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] @@ -608,12 +613,12 @@ Definition create2 : Value.t -> Value.t -> M := "call_data_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -626,12 +631,12 @@ Definition create2 : Value.t -> Value.t -> M := let _ := M.assign_local (| "init_code_gas" , M.call (| - M.get_name (| globals, "init_code_cost" |), + M.get_name (| globals, locals_stack, "init_code_cost" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "memory_size" |) + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -640,46 +645,46 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), + M.get_name (| globals, locals_stack, "GAS_CREATE" |), BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "call_data_words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "call_data_words" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |), - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "init_code_gas" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_create2_contract_address" |), + M.get_name (| globals, locals_stack, "compute_create2_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "salt" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "salt" |); M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) @@ -688,27 +693,28 @@ Definition create2 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "generic_create" |), + M.get_name (| globals, locals_stack, "generic_create" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "endowment" |); - M.get_name (| globals, "contract_address" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |); - M.get_name (| globals, "init_code_gas" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "endowment" |); + M.get_name (| globals, locals_stack, "contract_address" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |); + M.get_name (| globals, locals_stack, "init_code_gas" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -720,9 +726,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -730,9 +736,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -740,63 +746,64 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "is_staticcall"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in (* At stmt: unsupported node type: ImportFrom *) let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := @@ -804,24 +811,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -841,11 +848,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -853,10 +860,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -864,7 +871,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -872,10 +879,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -883,27 +890,27 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -916,23 +923,23 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -946,16 +953,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -967,14 +974,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -983,8 +990,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -996,12 +1004,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1012,12 +1020,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1028,9 +1036,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1038,9 +1046,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1048,9 +1056,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1058,9 +1066,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1068,9 +1076,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1078,12 +1086,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1093,28 +1101,28 @@ Definition call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1124,16 +1132,16 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |) )) @@ -1141,7 +1149,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1149,7 +1157,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -1157,13 +1165,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1171,56 +1179,56 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |), + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1229,25 +1237,25 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) )) |); - M.get_name (| globals, "WriteInStaticContext" |) + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1256,17 +1264,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1276,32 +1284,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1309,14 +1317,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -1328,12 +1337,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1344,12 +1353,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1360,9 +1369,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1370,9 +1379,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1380,9 +1389,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1390,9 +1399,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1400,26 +1409,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1429,28 +1438,28 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in @@ -1459,13 +1468,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1473,58 +1482,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "access_gas_cost" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "access_gas_cost" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1533,17 +1542,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1553,32 +1562,32 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "return_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "return_data" |), Constant.bytes "" |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1586,14 +1595,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1605,12 +1615,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1620,28 +1630,28 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "beneficiary" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "beneficiary" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ (* else *) @@ -1653,20 +1663,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1679,7 +1689,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1687,32 +1697,32 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ - UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "is_static" |) |); - M.get_name (| globals, "WriteInStaticContext" |) + UnOp.not (| M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "is_static" |) |); + M.get_name (| globals, locals_stack, "WriteInStaticContext" |) ], make_dict [] |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1720,33 +1730,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1756,9 +1766,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1766,19 +1776,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1788,15 +1798,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1808,12 +1819,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1824,12 +1835,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1840,9 +1851,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1850,9 +1861,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1860,9 +1871,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1870,9 +1881,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1880,12 +1891,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1895,104 +1906,105 @@ Definition delegatecall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "code_address" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "code_address" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "code_address" |) + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition staticcall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -2004,12 +2016,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2020,12 +2032,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2036,9 +2048,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2046,9 +2058,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2056,9 +2068,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2066,9 +2078,9 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2076,12 +2088,12 @@ Definition staticcall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -2091,110 +2103,111 @@ Definition staticcall : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "to" |), - M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |) + M.get_name (| globals, locals_stack, "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_WARM_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_WARM_ACCESS" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accessed_addresses" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accessed_addresses" |), "add" |), make_list [ - M.get_name (| globals, "to" |) + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) in let _ := M.assign_local (| "access_gas_cost" , - M.get_name (| globals, "GAS_COLD_ACCOUNT_ACCESS" |) + M.get_name (| globals, locals_stack, "GAS_COLD_ACCOUNT_ACCESS" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "access_gas_cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "access_gas_cost" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition revert : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason @@ -2206,9 +2219,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2216,9 +2229,9 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -2226,54 +2239,54 @@ Definition revert : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ - M.get_name (| globals, "output" |) + M.get_name (| globals, locals_stack, "output" |) ], make_dict [] |) |) in - let _ := M.raise (| Some (M.get_name (| globals, "Revert" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "Revert" |)) |) in let _ := M.pass (| |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/interpreter.v b/CoqOfPython/ethereum/shanghai/vm/interpreter.v index f12f04a..6a8a73e 100644 --- a/CoqOfPython/ethereum/shanghai/vm/interpreter.v +++ b/CoqOfPython/ethereum/shanghai/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.interpreter". +Definition globals : Globals.t := "ethereum.shanghai.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -128,7 +130,7 @@ Axiom ethereum_shanghai_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -151,8 +153,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -174,9 +177,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -188,10 +191,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -199,44 +202,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -250,10 +253,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -266,10 +269,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -278,13 +281,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -294,12 +297,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -316,14 +319,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -331,7 +334,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -339,7 +342,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -351,22 +354,22 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) ], make_dict [] |) @@ -376,29 +379,29 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -406,8 +409,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -424,43 +428,43 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "mark_account_created" |), + M.get_name (| globals, locals_stack, "mark_account_created" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -468,24 +472,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -493,22 +497,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -528,13 +533,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -546,17 +551,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -564,10 +569,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -575,12 +580,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -592,10 +597,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -603,13 +608,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -617,22 +622,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -650,14 +656,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -665,13 +671,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/memory.v b/CoqOfPython/ethereum/shanghai/vm/memory.v index 6e9a8b2..a2fd291 100644 --- a/CoqOfPython/ethereum/shanghai/vm/memory.v +++ b/CoqOfPython/ethereum/shanghai/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.memory". +Definition globals : Globals.t := "ethereum.shanghai.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/__init__.v index 4a90702..db1d979 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], @@ -67,7 +69,7 @@ Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x05" ], @@ -77,7 +79,7 @@ Definition MODEXP_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x06" ], @@ -87,7 +89,7 @@ Definition ALT_BN128_ADD_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x07" ], @@ -97,7 +99,7 @@ Definition ALT_BN128_MUL_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x08" ], @@ -107,7 +109,7 @@ Definition ALT_BN128_PAIRING_CHECK_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition BLAKE2F_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x09" ], diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/alt_bn128.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/alt_bn128.v index 69c7cc0..4f8ddae 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/alt_bn128.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/alt_bn128.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.alt_bn128". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.alt_bn128". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -55,8 +57,9 @@ Axiom ethereum_shanghai_vm_exceptions_imports_OutOfGasError : IsImported globals "ethereum.shanghai.vm.exceptions" "OutOfGasError". Definition alt_bn128_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 addition precompiled contract. @@ -67,14 +70,14 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 150 ], @@ -86,18 +89,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -110,9 +113,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -120,18 +123,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -144,9 +147,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -154,18 +157,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -178,9 +181,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x1_bytes" |) + M.get_name (| globals, locals_stack, "x1_bytes" |) ], make_dict [] |) @@ -188,18 +191,18 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -212,28 +215,28 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y1_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y1_bytes" |) + M.get_name (| globals, locals_stack, "y1_bytes" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |); M.get_name (| globals, "x1_value" |); M.get_name (| globals, "y1_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |); M.get_name (| globals, locals_stack, "x1_value" |); M.get_name (| globals, locals_stack, "y1_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -249,20 +252,20 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , BinOp.add (| - M.get_name (| globals, "p0" |), - M.get_name (| globals, "p1" |) + M.get_name (| globals, locals_stack, "p0" |), + M.get_name (| globals, locals_stack, "p1" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -271,8 +274,9 @@ Definition alt_bn128_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 multiplication precompiled contract. @@ -283,14 +287,14 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6000 ], @@ -302,18 +306,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -326,9 +330,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "x0_bytes" |) + M.get_name (| globals, locals_stack, "x0_bytes" |) ], make_dict [] |) @@ -336,18 +340,18 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -360,9 +364,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y0_value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "y0_bytes" |) + M.get_name (| globals, locals_stack, "y0_bytes" |) ], make_dict [] |) @@ -370,21 +374,21 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "n" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -399,19 +403,19 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), - make_tuple [ M.get_name (| globals, "x0_value" |); M.get_name (| globals, "y0_value" |) ], + M.get_name (| globals, locals_stack, "i" |), + make_tuple [ M.get_name (| globals, locals_stack, "x0_value" |); M.get_name (| globals, locals_stack, "y0_value" |) ], ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "i" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "i" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -427,23 +431,23 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "p" , M.call (| - M.get_field (| M.get_name (| globals, "p0" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p0" |), "mul_by" |), make_list [ - M.get_name (| globals, "n" |) + M.get_name (| globals, locals_stack, "n" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.add (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "x" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "x" |), "to_be_bytes32" |), make_list [], make_dict [] |), M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "p" |), "y" |), "to_be_bytes32" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "p" |), "y" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -452,8 +456,9 @@ Definition alt_bn128_mul : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " The ALT_BN128 pairing check precompiled contract. @@ -464,23 +469,23 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 34000, BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -501,9 +506,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := Compare.not_eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -513,7 +518,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -522,7 +527,7 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -531,15 +536,15 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ BinOp.floor_div (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), @@ -555,9 +560,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 6 ], @@ -567,29 +572,29 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), + M.get_name (| globals, locals_stack, "data" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, - M.get_name (| globals, "j" |) + M.get_name (| globals, locals_stack, "j" |) |) |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 192 |), BinOp.mult (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "j" |), + M.get_name (| globals, locals_stack, "j" |), Constant.int 1 |) |) @@ -604,24 +609,24 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ALT_BN128_PRIME" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ALT_BN128_PRIME" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "values" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "values" |), "append" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -636,44 +641,44 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := |) in (* At stmt: unsupported node type: Try *) let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "p" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "p" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "q" |), "mul_by" |), + M.get_field (| M.get_name (| globals, locals_stack, "q" |), "mul_by" |), make_list [ - M.get_name (| globals, "ALT_BN128_CURVE_ORDER" |) + M.get_name (| globals, locals_stack, "ALT_BN128_CURVE_ORDER" |) ], make_dict [] |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "OutOfGasError" |) + M.get_name (| globals, locals_stack, "OutOfGasError" |) ], make_dict [] |) in @@ -682,18 +687,18 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "p" |), + M.get_name (| globals, locals_stack, "p" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP" |), "point_at_infinity" |), make_list [], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "q" |), + M.get_name (| globals, locals_stack, "q" |), M.call (| - M.get_field (| M.get_name (| globals, "BNP2" |), "point_at_infinity" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNP2" |), "point_at_infinity" |), make_list [], make_dict [] |) @@ -705,12 +710,12 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , BinOp.mult (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_name (| globals, "pairing" |), + M.get_name (| globals, locals_stack, "pairing" |), make_list [ - M.get_name (| globals, "q" |); - M.get_name (| globals, "p" |) + M.get_name (| globals, locals_stack, "q" |); + M.get_name (| globals, locals_stack, "p" |) ], make_dict [] |) @@ -731,9 +736,9 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "result" |), + M.get_name (| globals, locals_stack, "result" |), M.call (| - M.get_field (| M.get_name (| globals, "BNF12" |), "from_int" |), + M.get_field (| M.get_name (| globals, locals_stack, "BNF12" |), "from_int" |), make_list [ Constant.int 1 ], @@ -743,10 +748,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -760,10 +765,10 @@ Definition alt_bn128_pairing_check : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/blake2f.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/blake2f.v index 1bef272..cbbac2e 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/blake2f.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/blake2f.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.blake2f". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.blake2f". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -35,8 +37,9 @@ Axiom ethereum_shanghai_vm_exceptions_imports_InvalidParameter : IsImported globals "ethereum.shanghai.vm.exceptions" "InvalidParameter". Definition blake2f : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the Blake2 hash to output. @@ -47,79 +50,79 @@ Definition blake2f : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), Constant.int 213 |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign_local (| "blake2b" , M.call (| - M.get_name (| globals, "Blake2b" |), + M.get_name (| globals, locals_stack, "Blake2b" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "rounds" |); M.get_name (| globals, "h" |); M.get_name (| globals, "m" |); M.get_name (| globals, "t_0" |); M.get_name (| globals, "t_1" |); M.get_name (| globals, "f" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "rounds" |); M.get_name (| globals, locals_stack, "h" |); M.get_name (| globals, locals_stack, "m" |); M.get_name (| globals, locals_stack, "t_0" |); M.get_name (| globals, locals_stack, "t_1" |); M.get_name (| globals, locals_stack, "f" |) ], M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "get_blake2_parameters" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "get_blake2_parameters" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.mult (| - M.get_name (| globals, "GAS_BLAKE2_PER_ROUND" |), - M.get_name (| globals, "rounds" |) + M.get_name (| globals, locals_stack, "GAS_BLAKE2_PER_ROUND" |), + M.get_name (| globals, locals_stack, "rounds" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_name (| globals, "f" |), + M.get_name (| globals, locals_stack, "f" |), make_list [ Constant.int 0; Constant.int 1 ] |); - M.get_name (| globals, "InvalidParameter" |) + M.get_name (| globals, locals_stack, "InvalidParameter" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_field (| M.get_name (| globals, "blake2b" |), "compress" |), + M.get_field (| M.get_name (| globals, locals_stack, "blake2b" |), "compress" |), make_list [ - M.get_name (| globals, "rounds" |); - M.get_name (| globals, "h" |); - M.get_name (| globals, "m" |); - M.get_name (| globals, "t_0" |); - M.get_name (| globals, "t_1" |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "rounds" |); + M.get_name (| globals, locals_stack, "h" |); + M.get_name (| globals, locals_stack, "m" |); + M.get_name (| globals, locals_stack, "t_0" |); + M.get_name (| globals, locals_stack, "t_1" |); + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ecrecover.v index ac4b74e..37e81ce 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_shanghai_vm_memory_imports_buffer_read : IsImported globals "ethereum.shanghai.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/identity.v index 554096f..eedb8c2 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_shanghai_vm_gas_imports_charge_gas : IsImported globals "ethereum.shanghai.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/mapping.v index 9fd8e82..a6e0686 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/modexp.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/modexp.v index 9c94a82..8749a71 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/modexp.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/modexp.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.modexp". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.modexp". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,34 +40,35 @@ Definition GQUADDIVISOR : Value.t := M.run ltac:(M.monadic ( )). Definition modexp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates `(base**exp) % modulus` for arbitrary sized `base`, `exp` and. `modulus`. The return value is the same length as the modulus. " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "base_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -81,21 +84,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -111,21 +114,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_length" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -142,36 +145,36 @@ Definition modexp : Value.t -> Value.t -> M := "exp_start" , BinOp.add (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |), - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) |) |) in let _ := M.assign_local (| "exp_head" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -183,16 +186,16 @@ Definition modexp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "gas_cost" |), + M.get_name (| globals, locals_stack, "gas_cost" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |); - M.get_name (| globals, "exp_length" |); - M.get_name (| globals, "exp_head" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); + M.get_name (| globals, locals_stack, "exp_length" |); + M.get_name (| globals, locals_stack, "exp_head" |) ], make_dict [] |) @@ -204,12 +207,12 @@ Definition modexp : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "base_length" |), + M.get_name (| globals, locals_stack, "base_length" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "modulus_length" |), + M.get_name (| globals, locals_stack, "modulus_length" |), Constant.int 0 |) )) @@ -217,9 +220,9 @@ Definition modexp : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [], make_dict [] |) @@ -235,20 +238,20 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |) @@ -259,14 +262,14 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exp" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "exp_start" |); - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "exp_start" |); + M.get_name (| globals, locals_stack, "exp_length" |) ], make_dict [] |) @@ -277,21 +280,21 @@ Definition modexp : Value.t -> Value.t -> M := let _ := M.assign_local (| "modulus_start" , BinOp.add (| - M.get_name (| globals, "exp_start" |), - M.get_name (| globals, "exp_length" |) + M.get_name (| globals, locals_stack, "exp_start" |), + M.get_name (| globals, locals_stack, "exp_length" |) |) |) in let _ := M.assign_local (| "modulus" , M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); - M.get_name (| globals, "modulus_start" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "data" |); + M.get_name (| globals, locals_stack, "modulus_start" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -303,39 +306,39 @@ Definition modexp : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "modulus" |), + M.get_name (| globals, locals_stack, "modulus" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), BinOp.mult (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "00" ], make_dict [] |), - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exp" |); - M.get_name (| globals, "modulus" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exp" |); + M.get_name (| globals, locals_stack, "modulus" |) ], make_dict [] |) @@ -343,7 +346,7 @@ Definition modexp : Value.t -> Value.t -> M := make_dict [] |), "to_bytes" |), make_list [ - M.get_name (| globals, "modulus_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |); Constant.str "big" ], make_dict [] @@ -354,8 +357,9 @@ Definition modexp : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition complexity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length" ] in + ltac:(M.monadic ( let _ := Constant.str " Estimate the complexity of performing a modular exponentiation. @@ -377,19 +381,19 @@ Definition complexity : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_length" , M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "base_length" |) + M.get_name (| globals, locals_stack, "base_length" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -401,7 +405,7 @@ Definition complexity : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "max_length" |), + M.get_name (| globals, locals_stack, "max_length" |), Constant.int 7 |), Constant.int 8 @@ -409,15 +413,16 @@ Definition complexity : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.pow (| - M.get_name (| globals, "words" |), + M.get_name (| globals, locals_stack, "words" |), Constant.int 2 |) |) in M.pure Constant.None_)). Definition iterations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the number of iterations required to perform a modular exponentiation. @@ -443,12 +448,12 @@ Definition iterations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "exponent_head" |), + M.get_name (| globals, locals_stack, "exponent_head" |), Constant.int 0 |) )) @@ -458,7 +463,7 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -472,7 +477,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "exponent_length" |), + M.get_name (| globals, locals_stack, "exponent_length" |), Constant.int 32 |), (* then *) @@ -480,10 +485,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bit_length" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -495,7 +500,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bit_length" |), + M.get_name (| globals, locals_stack, "bit_length" |), Constant.int 0 |), (* then *) @@ -512,7 +517,7 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "count" , - M.get_name (| globals, "bit_length" |) + M.get_name (| globals, locals_stack, "bit_length" |) |) in M.pure Constant.None_ (* else *) @@ -523,9 +528,9 @@ Definition iterations : Value.t -> Value.t -> M := Constant.int 8, BinOp.sub (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "exponent_length" |) + M.get_name (| globals, locals_stack, "exponent_length" |) ], make_dict [] |), @@ -536,10 +541,10 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "bits_part" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "exponent_head" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent_head" |), "bit_length" |), make_list [], make_dict [] |) @@ -551,7 +556,7 @@ Definition iterations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "bits_part" |), + M.get_name (| globals, locals_stack, "bits_part" |), Constant.int 0 |), (* then *) @@ -569,8 +574,8 @@ Definition iterations : Value.t -> Value.t -> M := let _ := M.assign_local (| "count" , BinOp.add (| - M.get_name (| globals, "length_part" |), - M.get_name (| globals, "bits_part" |) + M.get_name (| globals, locals_stack, "length_part" |), + M.get_name (| globals, locals_stack, "bits_part" |) |) |) in M.pure Constant.None_ @@ -579,11 +584,11 @@ Definition iterations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "count" |); + M.get_name (| globals, locals_stack, "count" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -596,8 +601,9 @@ Definition iterations : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "base_length"; "modulus_length"; "exponent_length"; "exponent_head" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the gas cost of performing a modular exponentiation. @@ -626,10 +632,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "multiplication_complexity" , M.call (| - M.get_name (| globals, "complexity" |), + M.get_name (| globals, locals_stack, "complexity" |), make_list [ - M.get_name (| globals, "base_length" |); - M.get_name (| globals, "modulus_length" |) + M.get_name (| globals, locals_stack, "base_length" |); + M.get_name (| globals, locals_stack, "modulus_length" |) ], make_dict [] |) @@ -637,10 +643,10 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "iteration_count" , M.call (| - M.get_name (| globals, "iterations" |), + M.get_name (| globals, locals_stack, "iterations" |), make_list [ - M.get_name (| globals, "exponent_length" |); - M.get_name (| globals, "exponent_head" |) + M.get_name (| globals, locals_stack, "exponent_length" |); + M.get_name (| globals, locals_stack, "exponent_head" |) ], make_dict [] |) @@ -648,27 +654,27 @@ Definition gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "cost" , BinOp.mult (| - M.get_name (| globals, "multiplication_complexity" |), - M.get_name (| globals, "iteration_count" |) + M.get_name (| globals, locals_stack, "multiplication_complexity" |), + M.get_name (| globals, locals_stack, "iteration_count" |) |) |) in let _ := M.assign_op_local (| BinOp.floor_div, "cost", - M.get_name (| globals, "GQUADDIVISOR" |) + M.get_name (| globals, locals_stack, "GQUADDIVISOR" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], make_dict [] |); - M.get_name (| globals, "cost" |) + M.get_name (| globals, locals_stack, "cost" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ripemd160.v index 9ca951c..5ba441d 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_shanghai_vm_gas_imports_charge_gas : IsImported globals "ethereum.shanghai.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/sha256.v index d8d222a..206c822 100644 --- a/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/shanghai/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.shanghai.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_shanghai_vm_gas_imports_charge_gas : IsImported globals "ethereum.shanghai.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/shanghai/vm/runtime.v b/CoqOfPython/ethereum/shanghai/vm/runtime.v index 44bf9bf..e5e7231 100644 --- a/CoqOfPython/ethereum/shanghai/vm/runtime.v +++ b/CoqOfPython/ethereum/shanghai/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.runtime". +Definition globals : Globals.t := "ethereum.shanghai.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_shanghai_vm_instructions_imports_Ops : IsImported globals "ethereum.shanghai.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/shanghai/vm/stack.v b/CoqOfPython/ethereum/shanghai/vm/stack.v index cbab960..a9b9678 100644 --- a/CoqOfPython/ethereum/shanghai/vm/stack.v +++ b/CoqOfPython/ethereum/shanghai/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.shanghai.vm.stack". +Definition globals : Globals.t := "ethereum.shanghai.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_shanghai_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.shanghai.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/__init__.v b/CoqOfPython/ethereum/spurious_dragon/__init__.v index 1f1b6ac..43e92cd 100644 --- a/CoqOfPython/ethereum/spurious_dragon/__init__.v +++ b/CoqOfPython/ethereum/spurious_dragon/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.__init__". +Definition globals : Globals.t := "ethereum.spurious_dragon.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -16,7 +18,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 2675000 ], diff --git a/CoqOfPython/ethereum/spurious_dragon/blocks.v b/CoqOfPython/ethereum/spurious_dragon/blocks.v index 1057a2e..b0c41a7 100644 --- a/CoqOfPython/ethereum/spurious_dragon/blocks.v +++ b/CoqOfPython/ethereum/spurious_dragon/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.blocks". +Definition globals : Globals.t := "ethereum.spurious_dragon.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/spurious_dragon/bloom.v b/CoqOfPython/ethereum/spurious_dragon/bloom.v index ba09205..3d5bc38 100644 --- a/CoqOfPython/ethereum/spurious_dragon/bloom.v +++ b/CoqOfPython/ethereum/spurious_dragon/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.bloom". +Definition globals : Globals.t := "ethereum.spurious_dragon.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_spurious_dragon_fork_types_imports_Bloom : IsImported globals "ethereum.spurious_dragon.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/fork.v b/CoqOfPython/ethereum/spurious_dragon/fork.v index db39a8f..a7f269c 100644 --- a/CoqOfPython/ethereum/spurious_dragon/fork.v +++ b/CoqOfPython/ethereum/spurious_dragon/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.fork". +Definition globals : Globals.t := "ethereum.spurious_dragon.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -136,7 +138,7 @@ Axiom ethereum_spurious_dragon_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 5, @@ -160,7 +162,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -183,8 +185,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -204,13 +207,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -233,7 +237,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -244,9 +248,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -268,17 +272,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -291,13 +295,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -308,20 +312,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -346,111 +351,111 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "chain" |), "chain_id" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "chain_id" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -459,9 +464,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -470,9 +475,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -486,8 +491,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -506,95 +512,95 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -603,28 +609,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -650,26 +657,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -677,8 +684,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -696,9 +704,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -706,25 +714,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -733,41 +741,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -791,35 +800,36 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "chain_id" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "chain_id" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -843,13 +853,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -864,8 +874,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -908,51 +919,51 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -960,18 +971,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -979,55 +990,55 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); + M.get_name (| globals, locals_stack, "tx" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1036,56 +1047,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1096,8 +1107,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1122,27 +1134,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1151,9 +1163,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1171,46 +1183,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1221,19 +1233,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1242,23 +1254,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1266,16 +1278,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1289,13 +1301,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1310,11 +1322,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1322,88 +1334,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1416,8 +1428,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1446,44 +1459,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1495,19 +1508,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1520,8 +1533,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1549,30 +1563,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1580,98 +1594,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1679,10 +1693,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1690,20 +1704,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1712,10 +1726,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1723,41 +1737,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1765,31 +1779,31 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.not_eq (| - M.get_name (| globals, "coinbase_balance_after_mining_fee" |), + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in @@ -1800,20 +1814,20 @@ Definition process_transaction : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |) in @@ -1826,14 +1840,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1845,27 +1859,27 @@ Definition process_transaction : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "touched_accounts" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "touched_accounts" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1881,13 +1895,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1916,17 +1931,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1941,8 +1956,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1971,14 +1987,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -1986,7 +2002,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -1994,7 +2010,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -2008,9 +2024,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -2021,7 +2037,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -2034,14 +2050,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -2050,8 +2066,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain_id"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain_id"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -2074,47 +2091,47 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -2123,12 +2140,12 @@ Definition recover_sender : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -2138,18 +2155,18 @@ Definition recover_sender : Value.t -> Value.t -> M := let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash_pre155" |), + M.get_name (| globals, locals_stack, "signing_hash_pre155" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2161,58 +2178,58 @@ Definition recover_sender : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 35, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), BinOp.add (| Constant.int 36, BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 35 |), BinOp.mult (| - M.get_name (| globals, "chain_id" |), + M.get_name (| globals, locals_stack, "chain_id" |), Constant.int 2 |) |); M.call (| - M.get_name (| globals, "signing_hash_155" |), + M.get_name (| globals, locals_stack, "signing_hash_155" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "chain_id" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "chain_id" |) ], make_dict [] |) @@ -2224,13 +2241,13 @@ Definition recover_sender : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2245,8 +2262,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_pre155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a legacy (pre EIP 155) signature. @@ -2262,12 +2280,12 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2278,8 +2296,9 @@ Definition signing_hash_pre155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash_155 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "chain_id" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "chain_id" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in a EIP 155 signature. @@ -2297,19 +2316,19 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |); M.get_name (| globals, "chain_id" |); M.call (| - M.get_name (| globals, "Uint" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); M.get_name (| globals, locals_stack, "chain_id" |); M.call (| + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -2325,8 +2344,9 @@ Definition signing_hash_155 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2360,12 +2380,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2376,8 +2396,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2408,18 +2429,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2436,10 +2457,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2456,8 +2477,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2475,8 +2496,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2518,26 +2540,26 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| Constant.int 1, BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2555,13 +2577,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2569,9 +2591,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.sub (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), @@ -2584,7 +2606,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2594,7 +2616,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2604,13 +2626,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/fork_types.v b/CoqOfPython/ethereum/spurious_dragon/fork_types.v index 92672ad..a204fad 100644 --- a/CoqOfPython/ethereum/spurious_dragon/fork_types.v +++ b/CoqOfPython/ethereum/spurious_dragon/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.fork_types". +Definition globals : Globals.t := "ethereum.spurious_dragon.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/spurious_dragon/state.v b/CoqOfPython/ethereum/spurious_dragon/state.v index d7957d0..1c27206 100644 --- a/CoqOfPython/ethereum/spurious_dragon/state.v +++ b/CoqOfPython/ethereum/spurious_dragon/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.state". +Definition globals : Globals.t := "ethereum.spurious_dragon.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,8 +710,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has zero nonce, empty code and zero balance. @@ -714,10 +732,10 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -725,9 +743,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -737,12 +755,12 @@ Definition is_account_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -753,8 +771,9 @@ Definition is_account_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists_and_is_empty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists and has zero nonce, empty code and zero balance. @@ -775,10 +794,10 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -786,15 +805,15 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.and (| Compare.is_not (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -804,12 +823,12 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -822,8 +841,9 @@ Definition account_exists_and_is_empty : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_account_alive : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Check whether is an account is both in the state and non empty. @@ -842,10 +862,10 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -854,7 +874,7 @@ Definition is_account_alive : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "account" |), + M.get_name (| globals, locals_stack, "account" |), Constant.None_ |), (* then *) @@ -868,9 +888,9 @@ Definition is_account_alive : Value.t -> Value.t -> M := let _ := M.return_ (| UnOp.not (| BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -880,12 +900,12 @@ Definition is_account_alive : Value.t -> Value.t -> M := ltac:(M.monadic ( BoolOp.and (| Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |), ltac:(M.monadic ( Compare.eq (| - M.get_field (| M.get_name (| globals, "account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "balance" |), Constant.int 0 |) )) @@ -898,28 +918,29 @@ Definition is_account_alive : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -929,36 +950,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -975,19 +998,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -1003,21 +1027,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -1029,8 +1053,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -1044,19 +1069,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -1073,19 +1099,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -1100,11 +1127,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/spurious_dragon/transactions.v b/CoqOfPython/ethereum/spurious_dragon/transactions.v index d563ae6..d732447 100644 --- a/CoqOfPython/ethereum/spurious_dragon/transactions.v +++ b/CoqOfPython/ethereum/spurious_dragon/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.transactions". +Definition globals : Globals.t := "ethereum.spurious_dragon.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/spurious_dragon/trie.v b/CoqOfPython/ethereum/spurious_dragon/trie.v index acd6b08..308456a 100644 --- a/CoqOfPython/ethereum/spurious_dragon/trie.v +++ b/CoqOfPython/ethereum/spurious_dragon/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.trie". +Definition globals : Globals.t := "ethereum.spurious_dragon.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_spurious_dragon_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/utils/__init__.v b/CoqOfPython/ethereum/spurious_dragon/utils/__init__.v index 05c126f..fb47a7a 100644 --- a/CoqOfPython/ethereum/spurious_dragon/utils/__init__.v +++ b/CoqOfPython/ethereum/spurious_dragon/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.utils.__init__". +Definition globals : Globals.t := "ethereum.spurious_dragon.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/spurious_dragon/utils/address.v b/CoqOfPython/ethereum/spurious_dragon/utils/address.v index a4a5c3d..cc80f3d 100644 --- a/CoqOfPython/ethereum/spurious_dragon/utils/address.v +++ b/CoqOfPython/ethereum/spurious_dragon/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.utils.address". +Definition globals : Globals.t := "ethereum.spurious_dragon.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_spurious_dragon_fork_types_imports_Address : IsImported globals "ethereum.spurious_dragon.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -56,11 +59,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -75,8 +78,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -96,14 +100,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -115,7 +119,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -124,9 +128,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -134,9 +138,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/utils/hexadecimal.v b/CoqOfPython/ethereum/spurious_dragon/utils/hexadecimal.v index bbdbabf..9848a7b 100644 --- a/CoqOfPython/ethereum/spurious_dragon/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/spurious_dragon/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.spurious_dragon.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_spurious_dragon_fork_types_imports_Root : IsImported globals "ethereum.spurious_dragon.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/spurious_dragon/utils/message.v b/CoqOfPython/ethereum/spurious_dragon/utils/message.v index a356277..9c1f9e7 100644 --- a/CoqOfPython/ethereum/spurious_dragon/utils/message.v +++ b/CoqOfPython/ethereum/spurious_dragon/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.utils.message". +Definition globals : Globals.t := "ethereum.spurious_dragon.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_spurious_dragon_utils_address_imports_compute_contract_address : IsImported globals "ethereum.spurious_dragon.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -82,10 +85,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -94,20 +97,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -121,7 +124,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -130,7 +133,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -139,10 +142,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -150,19 +153,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -171,14 +174,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -189,7 +192,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -201,7 +204,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/__init__.v b/CoqOfPython/ethereum/spurious_dragon/vm/__init__.v index 9637d09..96afc79 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/__init__.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.__init__". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -93,8 +95,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -107,30 +110,30 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) ], make_dict [] |) in @@ -138,19 +141,19 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) in @@ -162,8 +165,9 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -178,15 +182,15 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "RIPEMD160_ADDRESS" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "touched_accounts" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "touched_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -199,8 +203,8 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |), - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |), + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) |), (* then *) ltac:(M.monadic ( @@ -208,19 +212,19 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "RIPEMD160_ADDRESS" |) + M.get_name (| globals, locals_stack, "RIPEMD160_ADDRESS" |) ], make_dict [] |) in @@ -236,7 +240,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/exceptions.v b/CoqOfPython/ethereum/spurious_dragon/vm/exceptions.v index 5caf2c5..324690f 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/exceptions.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.exceptions". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -69,22 +71,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/gas.v b/CoqOfPython/ethereum/spurious_dragon/vm/gas.v index 6f64c28..9462610 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/gas.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.gas". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_spurious_dragon_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -86,7 +88,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -116,7 +118,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -126,7 +128,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -136,7 +138,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 50 ], @@ -166,7 +168,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -176,7 +178,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -196,7 +198,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -206,7 +208,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -216,7 +218,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -226,7 +228,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 400 ], @@ -236,7 +238,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -246,7 +248,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -256,7 +258,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -266,7 +268,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -276,7 +278,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -286,7 +288,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -296,7 +298,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -306,7 +308,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -326,7 +328,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -336,7 +338,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -346,7 +348,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -356,7 +358,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -366,7 +368,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -376,7 +378,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -386,7 +388,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -396,7 +398,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -406,7 +408,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -416,7 +418,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -426,7 +428,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -455,8 +457,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -469,13 +472,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -486,22 +489,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -511,8 +514,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -532,9 +536,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -544,15 +548,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -561,16 +565,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -589,7 +594,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,12 +614,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -624,14 +629,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -645,9 +650,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -655,20 +660,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -681,8 +686,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -696,16 +701,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -713,9 +718,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -724,13 +729,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -740,10 +745,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -751,8 +756,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -783,13 +789,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -797,32 +803,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -836,18 +842,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -858,15 +864,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -875,8 +881,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -892,9 +899,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/__init__.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/__init__.v index a4fd34b..e153214 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/arithmetic.v index 2256f4d..1ba88bd 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/bitwise.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/bitwise.v index fc29c9b..925d2d6 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,42 +62,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -108,9 +112,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,42 +122,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -167,9 +172,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -177,42 +182,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -226,39 +232,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -273,9 +280,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -283,18 +290,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -302,7 +309,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -310,7 +317,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -324,15 +331,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -340,16 +347,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -357,16 +364,16 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/block.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/block.v index d8850a8..4eaa164 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/block.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.block". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/comparison.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/comparison.v index e7f431c..bc0bd53 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/control_flow.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/control_flow.v index f96d87f..5673b3f 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/environment.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/environment.v index 00c40fe..fff0fc8 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -60,8 +62,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -73,21 +76,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -96,14 +99,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -116,12 +120,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -130,42 +134,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -178,21 +183,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -201,14 +206,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -220,21 +226,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -243,14 +249,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -262,31 +269,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -300,30 +308,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -334,13 +342,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -349,14 +357,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -368,24 +377,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -397,14 +406,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -420,9 +430,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -430,9 +440,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -440,9 +450,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -451,12 +461,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -469,76 +479,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -550,24 +561,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -579,14 +590,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -602,9 +614,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -612,9 +624,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -622,9 +634,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -633,12 +645,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -651,76 +663,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -732,21 +745,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -755,14 +768,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -775,12 +789,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -789,26 +803,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -820,23 +834,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -849,12 +864,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -865,9 +880,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -875,9 +890,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -885,9 +900,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -896,12 +911,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -914,52 +929,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -967,27 +982,27 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/keccak.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/keccak.v index b4aecb5..d650183 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/log.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/log.v index db24bd8..5ac6e29 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/log.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.log". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_pop : IsImported globals "ethereum.spurious_dragon.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -66,9 +69,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -89,11 +92,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -102,9 +105,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -113,9 +116,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -128,74 +131,74 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -203,9 +206,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -213,9 +216,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -223,9 +226,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -233,9 +236,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/memory.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/memory.v index a320784..fd7b476 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/stack.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/stack.v index 4846fa5..89d8459 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_spurious_dragon_vm_memory_imports_buffer_read : IsImported globals "ethereum.spurious_dragon.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/storage.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/storage.v index 2c14d8c..adb9427 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,8 +44,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -58,9 +61,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -69,43 +72,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -119,9 +123,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -132,9 +136,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,11 +146,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -156,12 +160,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -170,14 +174,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -186,12 +190,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -200,8 +204,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -209,26 +213,26 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/system.v b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/system.v index 1bb34af..0709924 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/instructions/system.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.instructions.system". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -90,8 +92,9 @@ Axiom ethereum_spurious_dragon_vm_stack_imports_push : IsImported globals "ethereum.spurious_dragon.vm.stack" "push". Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -104,9 +107,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -114,9 +117,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -124,9 +127,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -134,23 +137,23 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -158,12 +161,12 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -173,28 +176,28 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -202,14 +205,14 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -222,15 +225,15 @@ Definition create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -246,10 +249,10 @@ Definition create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -258,11 +261,11 @@ Definition create : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -273,8 +276,8 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in M.pure Constant.None_ (* else *) @@ -283,29 +286,29 @@ Definition create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -320,27 +323,27 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -348,10 +351,10 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -359,23 +362,23 @@ Definition create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -388,21 +391,21 @@ Definition create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -417,14 +420,15 @@ Definition create : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -436,9 +440,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -446,9 +450,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -456,57 +460,58 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in @@ -516,24 +521,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -553,11 +558,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -565,10 +570,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -576,7 +581,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -584,10 +589,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -595,23 +600,23 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -624,19 +629,19 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -650,16 +655,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -671,14 +676,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -687,8 +692,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -700,12 +706,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -716,12 +722,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -732,9 +738,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -742,9 +748,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -752,9 +758,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -762,9 +768,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -772,9 +778,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -782,12 +788,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -799,15 +805,15 @@ Definition call : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), ltac:(M.monadic ( M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) @@ -816,7 +822,7 @@ Definition call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -824,7 +830,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -832,13 +838,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -846,61 +852,61 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -909,17 +915,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -930,26 +936,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -957,14 +963,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -976,12 +983,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -992,12 +999,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1008,9 +1015,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1018,9 +1025,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1028,9 +1035,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1038,9 +1045,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1048,26 +1055,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1078,13 +1085,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1092,58 +1099,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1152,17 +1159,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1173,26 +1180,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1200,14 +1207,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1219,12 +1227,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1234,27 +1242,27 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| BoolOp.and (| UnOp.not (| M.call (| - M.get_name (| globals, "is_account_alive" |), + M.get_name (| globals, locals_stack, "is_account_alive" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), ltac:(M.monadic ( Compare.not_eq (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |), @@ -1267,7 +1275,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1276,33 +1284,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1314,15 +1322,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1330,20 +1338,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1351,33 +1359,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1387,9 +1395,9 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in @@ -1397,19 +1405,19 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ - M.get_name (| globals, "beneficiary" |) + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) in @@ -1419,15 +1427,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1439,12 +1448,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1455,12 +1464,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1471,9 +1480,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1481,9 +1490,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1491,9 +1500,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1501,9 +1510,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1511,12 +1520,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1525,68 +1534,68 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/interpreter.v b/CoqOfPython/ethereum/spurious_dragon/vm/interpreter.v index e58aeba..06ea653 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/interpreter.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.interpreter". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -120,7 +122,7 @@ Axiom ethereum_spurious_dragon_vm_runtime_imports_get_valid_jump_destinations : Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -143,8 +145,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -166,9 +169,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -180,10 +183,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -191,44 +194,44 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -242,10 +245,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -258,10 +261,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -270,13 +273,13 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_exists_and_is_empty" |), + M.get_name (| globals, locals_stack, "account_exists_and_is_empty" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -286,12 +289,12 @@ Definition process_message_call : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |), "add" |), make_list [ M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_field (| M.get_name (| globals, "message" |), "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |) ], make_dict [] |) @@ -308,14 +311,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -323,7 +326,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "touched_accounts" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -331,7 +334,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -343,48 +346,48 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "touched_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "touched_accounts" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "touched_accounts" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -392,8 +395,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -410,35 +414,35 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -446,24 +450,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -471,22 +475,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -506,13 +511,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -524,17 +529,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -542,10 +547,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -553,12 +558,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -570,10 +575,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -581,13 +586,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -595,22 +600,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -628,14 +634,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -643,13 +649,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/memory.v b/CoqOfPython/ethereum/spurious_dragon/vm/memory.v index b492085..6996c23 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/memory.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.memory". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/__init__.v index 1d7b891..9865012 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ecrecover.v index c1ae66e..4c51c76 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_spurious_dragon_vm_memory_imports_buffer_read : IsImported globals "ethereum.spurious_dragon.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/identity.v index c36d5ee..a610f97 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_spurious_dragon_vm_gas_imports_charge_gas : IsImported globals "ethereum.spurious_dragon.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/mapping.v index cba9815..775cb99 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ripemd160.v index 029a148..518a15d 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_spurious_dragon_vm_gas_imports_charge_gas : IsImported globals "ethereum.spurious_dragon.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/sha256.v index c155fe7..19322f3 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_spurious_dragon_vm_gas_imports_charge_gas : IsImported globals "ethereum.spurious_dragon.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/runtime.v b/CoqOfPython/ethereum/spurious_dragon/vm/runtime.v index 9f6ecd8..bf9c04b 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/runtime.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.runtime". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_spurious_dragon_vm_instructions_imports_Ops : IsImported globals "ethereum.spurious_dragon.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/spurious_dragon/vm/stack.v b/CoqOfPython/ethereum/spurious_dragon/vm/stack.v index b6fb48a..85f5983 100644 --- a/CoqOfPython/ethereum/spurious_dragon/vm/stack.v +++ b/CoqOfPython/ethereum/spurious_dragon/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.spurious_dragon.vm.stack". +Definition globals : Globals.t := "ethereum.spurious_dragon.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_spurious_dragon_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.spurious_dragon.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/__init__.v b/CoqOfPython/ethereum/tangerine_whistle/__init__.v index fd543a7..b109ac7 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/__init__.v +++ b/CoqOfPython/ethereum/tangerine_whistle/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.__init__". +Definition globals : Globals.t := "ethereum.tangerine_whistle.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -15,7 +17,7 @@ Axiom ethereum_fork_criteria_imports_ByBlockNumber : Definition FORK_CRITERIA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "ByBlockNumber" |), + M.get_name (| globals, locals_stack, "ByBlockNumber" |), make_list [ Constant.int 2463000 ], diff --git a/CoqOfPython/ethereum/tangerine_whistle/blocks.v b/CoqOfPython/ethereum/tangerine_whistle/blocks.v index b921a0d..17115ef 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/blocks.v +++ b/CoqOfPython/ethereum/tangerine_whistle/blocks.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.blocks". +Definition globals : Globals.t := "ethereum.tangerine_whistle.blocks". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/tangerine_whistle/bloom.v b/CoqOfPython/ethereum/tangerine_whistle/bloom.v index ccf56cd..263f8cb 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/bloom.v +++ b/CoqOfPython/ethereum/tangerine_whistle/bloom.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.bloom". +Definition globals : Globals.t := "ethereum.tangerine_whistle.bloom". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -37,8 +39,9 @@ Axiom ethereum_tangerine_whistle_fork_types_imports_Bloom : IsImported globals "ethereum.tangerine_whistle.fork_types" "Bloom". Definition add_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bloom"; "bloom_entry" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bloom"; "bloom_entry" ] in + ltac:(M.monadic ( let _ := Constant.str " Add a bloom entry to the bloom filter (`bloom`). @@ -56,29 +59,29 @@ Definition add_to_bloom : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "bloom_entry" |) + M.get_name (| globals, locals_stack, "bloom_entry" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), make_tuple [ Constant.int 0; Constant.int 2; Constant.int 4 ], ltac:(M.monadic ( let _ := M.assign_local (| "bit_to_set" , BinOp.bit_and (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "hash" |), - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "hash" |), + M.get_name (| globals, locals_stack, "idx" |), BinOp.add (| - M.get_name (| globals, "idx" |), + M.get_name (| globals, locals_stack, "idx" |), Constant.int 2 |), Constant.None_ @@ -93,13 +96,13 @@ Definition add_to_bloom : Value.t -> Value.t -> M := "bit_index" , BinOp.sub (| Constant.int 2047, - M.get_name (| globals, "bit_to_set" |) + M.get_name (| globals, locals_stack, "bit_to_set" |) |) |) in let _ := M.assign_local (| "byte_index" , BinOp.floor_div (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) in @@ -110,7 +113,7 @@ Definition add_to_bloom : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 7, BinOp.mod_ (| - M.get_name (| globals, "bit_index" |), + M.get_name (| globals, locals_stack, "bit_index" |), Constant.int 8 |) |) @@ -118,15 +121,15 @@ Definition add_to_bloom : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), BinOp.bit_or (| M.get_subscript (| - M.get_name (| globals, "bloom" |), - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "bloom" |), + M.get_name (| globals, locals_stack, "byte_index" |) |), - M.get_name (| globals, "bit_value" |) + M.get_name (| globals, locals_stack, "bit_value" |) |) |) in M.pure Constant.None_ @@ -138,8 +141,9 @@ Definition add_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition logs_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the logs bloom from a list of log entries. @@ -159,27 +163,27 @@ Definition logs_bloom : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "log" |), - M.get_name (| globals, "logs" |), + M.get_name (| globals, locals_stack, "log" |), + M.get_name (| globals, locals_stack, "logs" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_field (| M.get_name (| globals, "log" |), "address" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "address" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "topic" |), - M.get_field (| M.get_name (| globals, "log" |), "topics" |), + M.get_name (| globals, locals_stack, "topic" |), + M.get_field (| M.get_name (| globals, locals_stack, "log" |), "topics" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "add_to_bloom" |), + M.get_name (| globals, locals_stack, "add_to_bloom" |), make_list [ - M.get_name (| globals, "bloom" |); - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "bloom" |); + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -197,9 +201,9 @@ Definition logs_bloom : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ - M.get_name (| globals, "bloom" |) + M.get_name (| globals, locals_stack, "bloom" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/fork.v b/CoqOfPython/ethereum/tangerine_whistle/fork.v index bc0e99d..3658e86 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/fork.v +++ b/CoqOfPython/ethereum/tangerine_whistle/fork.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.fork". +Definition globals : Globals.t := "ethereum.tangerine_whistle.fork". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -134,7 +136,7 @@ Axiom ethereum_tangerine_whistle_vm_interpreter_imports_process_message_call : Definition BLOCK_REWARD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mult (| Constant.int 5, @@ -158,7 +160,7 @@ Definition GAS_LIMIT_MINIMUM : Value.t := M.run ltac:(M.monadic ( Definition MINIMUM_DIFFICULTY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 131072 ], @@ -181,8 +183,9 @@ Definition BlockChain : Value.t := ]. Definition apply_fork : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "old" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "old" ] in + ltac:(M.monadic ( let _ := Constant.str " Transforms the state from the previous hard fork (`old`) into the block chain object for this hard fork and returns it. @@ -202,13 +205,14 @@ Definition apply_fork : Value.t -> Value.t -> M := Upgraded block chain object for this hard fork. " in let _ := M.return_ (| - M.get_name (| globals, "old" |) + M.get_name (| globals, locals_stack, "old" |) |) in M.pure Constant.None_)). Definition get_last_256_block_hashes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain the list of hashes of the previous 256 blocks in order of increasing block number. @@ -231,7 +235,7 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "recent_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -242,9 +246,9 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "recent_blocks" |) + M.get_name (| globals, locals_stack, "recent_blocks" |) ], make_dict [] |), @@ -266,17 +270,17 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "prev_block_hash" , - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "parent_hash" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "parent_hash" |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "prev_block_hash" |) + M.get_name (| globals, locals_stack, "prev_block_hash" |) ], make_dict [] |) in @@ -289,13 +293,13 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := let _ := M.assign_local (| "most_recent_block_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.get_field (| M.get_subscript (| - M.get_name (| globals, "recent_blocks" |), + M.get_name (| globals, locals_stack, "recent_blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) ], @@ -306,20 +310,21 @@ Definition get_last_256_block_hashes : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "recent_block_hashes" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_block_hashes" |), "append" |), make_list [ - M.get_name (| globals, "most_recent_block_hash" |) + M.get_name (| globals, locals_stack, "most_recent_block_hash" |) ], make_dict [] |) in let _ := M.return_ (| - M.get_name (| globals, "recent_block_hashes" |) + M.get_name (| globals, locals_stack, "recent_block_hashes" |) |) in M.pure Constant.None_)). Definition state_transition : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "chain"; "block" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "chain"; "block" ] in + ltac:(M.monadic ( let _ := Constant.str " Attempts to apply a block to an existing block chain. @@ -344,110 +349,110 @@ Definition state_transition : Value.t -> Value.t -> M := let _ := M.assign_local (| "parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "parent_header" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_ommers" |), + M.get_name (| globals, locals_stack, "validate_ommers" |), make_list [ - M.get_field (| M.get_name (| globals, "block" |), "ommers" |); - M.get_field (| M.get_name (| globals, "block" |), "header" |); - M.get_name (| globals, "chain" |) + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |); + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |) in let _ := M.assign_local (| "apply_body_output" , M.call (| - M.get_name (| globals, "apply_body" |), + M.get_name (| globals, locals_stack, "apply_body" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "state" |); M.call (| - M.get_name (| globals, "get_last_256_block_hashes" |), + M.get_name (| globals, locals_stack, "get_last_256_block_hashes" |), make_list [ - M.get_name (| globals, "chain" |) + M.get_name (| globals, locals_stack, "chain" |) ], make_dict [] |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "coinbase" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "number" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_limit" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "timestamp" |); - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "block" |), "transactions" |); - M.get_field (| M.get_name (| globals, "block" |), "ommers" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "coinbase" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "number" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_limit" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "timestamp" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "transactions" |); + M.get_field (| M.get_name (| globals, locals_stack, "block" |), "ommers" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_gas_used" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "gas_used" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_gas_used" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "gas_used" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "transactions_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "transactions_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "transactions_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "transactions_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "state_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "state_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "state_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "state_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "receipt_root" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "receipt_root" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "receipt_root" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "receipt_root" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "apply_body_output" |), "block_logs_bloom" |), - M.get_field (| M.get_field (| M.get_name (| globals, "block" |), "header" |), "bloom" |) + M.get_field (| M.get_name (| globals, locals_stack, "apply_body_output" |), "block_logs_bloom" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "block" |), "header" |), "bloom" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), "append" |), make_list [ - M.get_name (| globals, "block" |) + M.get_name (| globals, locals_stack, "block" |) ], make_dict [] |) in @@ -456,9 +461,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |) + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |) ], make_dict [] |), @@ -467,9 +472,9 @@ Definition state_transition : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.assign (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| Constant.int 255 |), Constant.None_, Constant.None_ @@ -483,8 +488,9 @@ Definition state_transition : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_header : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header"; "parent_header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header"; "parent_header" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a block header. @@ -503,95 +509,95 @@ Definition validate_header : Value.t -> Value.t -> M := Parent Header of the header to check for correctness " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt (| - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |), - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "parent_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "number" |), Constant.int 1 |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "check_gas_limit" |), + M.get_name (| globals, locals_stack, "check_gas_limit" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "gas_limit" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "gas_limit" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ], make_dict [] |), Constant.int 32 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_difficulty" , M.call (| - M.get_name (| globals, "calculate_block_difficulty" |), + M.get_name (| globals, locals_stack, "calculate_block_difficulty" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "parent_header" |), "difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "parent_header" |), "difficulty" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |), - M.get_name (| globals, "block_difficulty" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |), + M.get_name (| globals, locals_stack, "block_difficulty" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "block_parent_hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "parent_header" |) + M.get_name (| globals, locals_stack, "parent_header" |) ], make_dict [] |) @@ -600,28 +606,29 @@ Definition validate_header : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |), - M.get_name (| globals, "block_parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "block_parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "validate_proof_of_work" |), + M.get_name (| globals, locals_stack, "validate_proof_of_work" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) in M.pure Constant.None_)). Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Generate rlp hash of the header which is to be used for Proof-of-Work verification. @@ -647,26 +654,26 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_data_without_pow_artefacts" , make_list [ - M.get_field (| M.get_name (| globals, "header" |), "parent_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "ommers_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "coinbase" |); - M.get_field (| M.get_name (| globals, "header" |), "state_root" |); - M.get_field (| M.get_name (| globals, "header" |), "transactions_root" |); - M.get_field (| M.get_name (| globals, "header" |), "receipt_root" |); - M.get_field (| M.get_name (| globals, "header" |), "bloom" |); - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |); - M.get_field (| M.get_name (| globals, "header" |), "number" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_limit" |); - M.get_field (| M.get_name (| globals, "header" |), "gas_used" |); - M.get_field (| M.get_name (| globals, "header" |), "timestamp" |); - M.get_field (| M.get_name (| globals, "header" |), "extra_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "parent_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "ommers_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "coinbase" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "state_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "transactions_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "receipt_root" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "bloom" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_limit" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "gas_used" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "timestamp" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "extra_data" |) ] |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "header_data_without_pow_artefacts" |) + M.get_name (| globals, locals_stack, "header_data_without_pow_artefacts" |) ], make_dict [] |) @@ -674,8 +681,9 @@ Definition generate_header_hash_for_pow : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_proof_of_work : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the Proof of Work constraints. @@ -693,9 +701,9 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "header_hash" , M.call (| - M.get_name (| globals, "generate_header_hash_for_pow" |), + M.get_name (| globals, locals_stack, "generate_header_hash_for_pow" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -703,25 +711,25 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := let _ := M.assign_local (| "cache" , M.call (| - M.get_name (| globals, "generate_cache" |), + M.get_name (| globals, locals_stack, "generate_cache" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "mix_digest" |); M.get_name (| globals, "result" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "mix_digest" |); M.get_name (| globals, locals_stack, "result" |) ], M.call (| - M.get_name (| globals, "hashimoto_light" |), + M.get_name (| globals, locals_stack, "hashimoto_light" |), make_list [ - M.get_name (| globals, "header_hash" |); - M.get_field (| M.get_name (| globals, "header" |), "nonce" |); - M.get_name (| globals, "cache" |); + M.get_name (| globals, locals_stack, "header_hash" |); + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "nonce" |); + M.get_name (| globals, locals_stack, "cache" |); M.call (| - M.get_name (| globals, "dataset_size" |), + M.get_name (| globals, locals_stack, "dataset_size" |), make_list [ - M.get_field (| M.get_name (| globals, "header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "number" |) ], make_dict [] |) @@ -730,41 +738,42 @@ Definition validate_proof_of_work : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_name (| globals, "mix_digest" |), - M.get_field (| M.get_name (| globals, "header" |), "mix_digest" |) + M.get_name (| globals, locals_stack, "mix_digest" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "mix_digest" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "result" |) + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "U256_CEIL_VALUE" |), - M.get_field (| M.get_name (| globals, "header" |), "difficulty" |) + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |), + M.get_field (| M.get_name (| globals, locals_stack, "header" |), "difficulty" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in M.pure Constant.None_)). Definition check_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "gas_available" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "gas_available" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if the transaction is includable in the block. @@ -786,34 +795,35 @@ Definition check_transaction : Value.t -> Value.t -> M := If the transaction is not includable. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_name (| globals, "gas_available" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "recover_sender" |), + M.get_name (| globals, locals_stack, "recover_sender" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "sender_address" |) + M.get_name (| globals, locals_stack, "sender_address" |) |) in M.pure Constant.None_)). Definition make_receipt : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx"; "post_state"; "cumulative_gas_used"; "logs" ] in + ltac:(M.monadic ( let _ := Constant.str " Make the receipt for a transaction that was executed. @@ -837,13 +847,13 @@ Definition make_receipt : Value.t -> Value.t -> M := let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "Receipt" |), + M.get_name (| globals, locals_stack, "Receipt" |), make_list [], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) |) in M.pure Constant.None_)). @@ -858,8 +868,9 @@ Definition ApplyBodyOutput : Value.t := ]. Definition apply_body : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_hashes"; "coinbase"; "block_number"; "block_gas_limit"; "block_time"; "block_difficulty"; "transactions"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a block. @@ -900,50 +911,50 @@ Definition apply_body : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "gas_available" , - M.get_name (| globals, "block_gas_limit" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |) |) in (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "i" |); M.get_name (| globals, "tx" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "i" |); M.get_name (| globals, locals_stack, "tx" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "transactions" |) + M.get_name (| globals, locals_stack, "transactions" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "transactions_trie" |); + M.get_name (| globals, locals_stack, "transactions_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_address" , M.call (| - M.get_name (| globals, "check_transaction" |), + M.get_name (| globals, locals_stack, "check_transaction" |), make_list [ - M.get_name (| globals, "tx" |); - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "tx" |); + M.get_name (| globals, locals_stack, "gas_available" |) ], make_dict [] |) @@ -951,18 +962,18 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_local (| "env" , M.call (| - M.get_field (| M.get_name (| globals, "vm" |), "Environment" |), + M.get_field (| M.get_name (| globals, locals_stack, "vm" |), "Environment" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "gas_used" |); M.get_name (| globals, "logs" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "gas_used" |); M.get_name (| globals, locals_stack, "logs" |) ], M.call (| - M.get_name (| globals, "process_transaction" |), + M.get_name (| globals, locals_stack, "process_transaction" |), make_list [ - M.get_name (| globals, "env" |); - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "env" |); + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -970,55 +981,55 @@ Definition apply_body : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.sub, "gas_available", - M.get_name (| globals, "gas_used" |) + M.get_name (| globals, locals_stack, "gas_used" |) |) in let _ := M.assign_local (| "receipt" , M.call (| - M.get_name (| globals, "make_receipt" |), + M.get_name (| globals, locals_stack, "make_receipt" |), make_list [ - M.get_name (| globals, "tx" |); + M.get_name (| globals, locals_stack, "tx" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |); BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |); - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "receipts_trie" |); + M.get_name (| globals, locals_stack, "receipts_trie" |); M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) ], make_dict [] |) ], make_dict [] |); - M.get_name (| globals, "receipt" |) + M.get_name (| globals, locals_stack, "receipt" |) ], make_dict [] |) in let _ := M.assign_op_local (| BinOp.add, "block_logs", - M.get_name (| globals, "logs" |) + M.get_name (| globals, locals_stack, "logs" |) |) in M.pure Constant.None_ )), @@ -1027,56 +1038,56 @@ Definition apply_body : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "pay_rewards" |), + M.get_name (| globals, locals_stack, "pay_rewards" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "block_number" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "block_number" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |) in let _ := M.assign_local (| "block_gas_used" , BinOp.sub (| - M.get_name (| globals, "block_gas_limit" |), - M.get_name (| globals, "gas_available" |) + M.get_name (| globals, locals_stack, "block_gas_limit" |), + M.get_name (| globals, locals_stack, "gas_available" |) |) |) in let _ := M.assign_local (| "block_logs_bloom" , M.call (| - M.get_name (| globals, "logs_bloom" |), + M.get_name (| globals, locals_stack, "logs_bloom" |), make_list [ - M.get_name (| globals, "block_logs" |) + M.get_name (| globals, locals_stack, "block_logs" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ApplyBodyOutput" |), + M.get_name (| globals, locals_stack, "ApplyBodyOutput" |), make_list [ - M.get_name (| globals, "block_gas_used" |); + M.get_name (| globals, locals_stack, "block_gas_used" |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "transactions_trie" |) + M.get_name (| globals, locals_stack, "transactions_trie" |) ], make_dict [] |); M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_name (| globals, "receipts_trie" |) + M.get_name (| globals, locals_stack, "receipts_trie" |) ], make_dict [] |); - M.get_name (| globals, "block_logs_bloom" |); + M.get_name (| globals, locals_stack, "block_logs_bloom" |); M.call (| - M.get_name (| globals, "state_root" |), + M.get_name (| globals, locals_stack, "state_root" |), make_list [ - M.get_name (| globals, "state" |) + M.get_name (| globals, locals_stack, "state" |) ], make_dict [] |) @@ -1087,8 +1098,9 @@ Definition apply_body : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition validate_ommers : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "ommers"; "block_header"; "chain" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "ommers"; "block_header"; "chain" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the ommers mentioned in the block. @@ -1113,27 +1125,27 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_hash" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "block_header" |) + M.get_name (| globals, locals_stack, "block_header" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "rlp_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "rlp_hash" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "block_header" |), "ommers_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "ommers_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1142,9 +1154,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1162,46 +1174,46 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "ommer" |), "number" |), - M.get_field (| M.get_name (| globals, "block_header" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_parent_header" , M.get_field (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), BinOp.sub (| UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |), Constant.int 1 |) |), "header" |) |) in let _ := M.call (| - M.get_name (| globals, "validate_header" |), + M.get_name (| globals, locals_stack, "validate_header" |), make_list [ - M.get_name (| globals, "ommer" |); - M.get_name (| globals, "ommer_parent_header" |) + M.get_name (| globals, locals_stack, "ommer" |); + M.get_name (| globals, locals_stack, "ommer_parent_header" |) ], make_dict [] |) in @@ -1212,19 +1224,19 @@ Definition validate_ommers : Value.t -> Value.t -> M := )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt_e (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), Constant.int 2 |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1233,23 +1245,23 @@ Definition validate_ommers : Value.t -> Value.t -> M := Constant.str "(* At expr: unsupported node type: ListComp *)" |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [ - M.get_name (| globals, "ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |) ], make_dict [] |) @@ -1257,16 +1269,16 @@ Definition validate_ommers : Value.t -> Value.t -> M := make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "recent_canonical_blocks" , M.slice (| - M.get_field (| M.get_name (| globals, "chain" |), "blocks" |), + M.get_field (| M.get_name (| globals, locals_stack, "chain" |), "blocks" |), UnOp.sub (| BinOp.add (| - M.get_name (| globals, "MAX_OMMER_DEPTH" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |), Constant.int 1 |) |), Constant.None_, @@ -1280,13 +1292,13 @@ Definition validate_ommers : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "block" |), - M.get_name (| globals, "recent_canonical_blocks" |), + M.get_name (| globals, locals_stack, "block" |), + M.get_name (| globals, locals_stack, "recent_canonical_blocks" |), ltac:(M.monadic ( let _ := M.assign_local (| "recent_ommers_hashes" , M.call (| - M.get_field (| M.get_name (| globals, "recent_ommers_hashes" |), "union" |), + M.get_field (| M.get_name (| globals, locals_stack, "recent_ommers_hashes" |), "union" |), make_list [ Constant.str "(* At expr: unsupported node type: SetComp *)" ], @@ -1301,11 +1313,11 @@ Definition validate_ommers : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "ommer_index" |); M.get_name (| globals, "ommer" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "ommer_index" |); M.get_name (| globals, locals_stack, "ommer" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), @@ -1313,88 +1325,88 @@ Definition validate_ommers : Value.t -> Value.t -> M := let _ := M.assign_local (| "ommer_hash" , M.get_subscript (| - M.get_name (| globals, "ommers_hashes" |), - M.get_name (| globals, "ommer_index" |) + M.get_name (| globals, locals_stack, "ommers_hashes" |), + M.get_name (| globals, locals_stack, "ommer_index" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "block_hash" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "block_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_in (| - M.get_name (| globals, "ommer_hash" |), - M.get_name (| globals, "recent_ommers_hashes" |) + M.get_name (| globals, locals_stack, "ommer_hash" |), + M.get_name (| globals, locals_stack, "recent_ommers_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "ommer_age" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "block_header" |), "number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt_e (| Constant.int 1, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "ommer_age" |), - M.get_name (| globals, "MAX_OMMER_DEPTH" |) + M.get_name (| globals, locals_stack, "ommer_age" |), + M.get_name (| globals, locals_stack, "MAX_OMMER_DEPTH" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.in_ (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_name (| globals, "recent_canonical_block_hashes" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_name (| globals, locals_stack, "recent_canonical_block_hashes" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_field (| M.get_name (| globals, "ommer" |), "parent_hash" |), - M.get_field (| M.get_name (| globals, "block_header" |), "parent_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "parent_hash" |), + M.get_field (| M.get_name (| globals, locals_stack, "block_header" |), "parent_hash" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in @@ -1407,8 +1419,9 @@ Definition validate_ommers : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pay_rewards : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "block_number"; "coinbase"; "ommers" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "block_number"; "coinbase"; "ommers" ] in + ltac:(M.monadic ( let _ := Constant.str " Pay rewards to the block miner as well as the ommers miners. @@ -1437,44 +1450,44 @@ Definition pay_rewards : Value.t -> Value.t -> M := let _ := M.assign_local (| "miner_reward" , BinOp.add (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "ommers" |) + M.get_name (| globals, locals_stack, "ommers" |) ], make_dict [] |), BinOp.floor_div (| - M.get_name (| globals, "BLOCK_REWARD" |), + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |), Constant.int 32 |) |) |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "coinbase" |); - M.get_name (| globals, "miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "coinbase" |); + M.get_name (| globals, locals_stack, "miner_reward" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "ommer" |), - M.get_name (| globals, "ommers" |), + M.get_name (| globals, locals_stack, "ommer" |), + M.get_name (| globals, locals_stack, "ommers" |), ltac:(M.monadic ( let _ := M.assign_local (| "ommer_age" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_number" |), - M.get_field (| M.get_name (| globals, "ommer" |), "number" |) + M.get_name (| globals, locals_stack, "block_number" |), + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "number" |) |) ], make_dict [] @@ -1486,19 +1499,19 @@ Definition pay_rewards : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| Constant.int 8, - M.get_name (| globals, "ommer_age" |) + M.get_name (| globals, locals_stack, "ommer_age" |) |), - M.get_name (| globals, "BLOCK_REWARD" |) + M.get_name (| globals, locals_stack, "BLOCK_REWARD" |) |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "create_ether" |), + M.get_name (| globals, locals_stack, "create_ether" |), make_list [ - M.get_name (| globals, "state" |); - M.get_field (| M.get_name (| globals, "ommer" |), "coinbase" |); - M.get_name (| globals, "ommer_miner_reward" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "ommer" |), "coinbase" |); + M.get_name (| globals, locals_stack, "ommer_miner_reward" |) ], make_dict [] |) in @@ -1511,8 +1524,9 @@ Definition pay_rewards : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "env"; "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "env"; "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -1540,30 +1554,30 @@ Definition process_transaction : Value.t -> Value.t -> M := Logs generated during execution. " in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ M.call (| - M.get_name (| globals, "validate_transaction" |), + M.get_name (| globals, locals_stack, "validate_transaction" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "sender" , - M.get_field (| M.get_name (| globals, "env" |), "origin" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "origin" |) |) in let _ := M.assign_local (| "sender_account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) @@ -1571,98 +1585,98 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_fee" , BinOp.mult (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "nonce" |), - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.gt_e (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), BinOp.add (| - M.get_name (| globals, "gas_fee" |), - M.get_field (| M.get_name (| globals, "tx" |), "value" |) + M.get_name (| globals, locals_stack, "gas_fee" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |) |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.eq (| - M.get_field (| M.get_name (| globals, "sender_account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "code" |), M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "gas" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |) in let _ := M.assign_local (| "sender_balance_after_gas_fee" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "sender_account" |), "balance" |), - M.get_name (| globals, "gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender_account" |), "balance" |), + M.get_name (| globals, locals_stack, "gas_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_gas_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_gas_fee" |) ], make_dict [] |) in let _ := M.assign_local (| "message" , M.call (| - M.get_name (| globals, "prepare_message" |), + M.get_name (| globals, locals_stack, "prepare_message" |), make_list [ - M.get_name (| globals, "sender" |); - M.get_field (| M.get_name (| globals, "tx" |), "to" |); - M.get_field (| M.get_name (| globals, "tx" |), "value" |); - M.get_field (| M.get_name (| globals, "tx" |), "data" |); - M.get_name (| globals, "gas" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "sender" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |); + M.get_name (| globals, locals_stack, "gas" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1670,10 +1684,10 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "output" , M.call (| - M.get_name (| globals, "process_message_call" |), + M.get_name (| globals, locals_stack, "process_message_call" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -1681,20 +1695,20 @@ Definition process_transaction : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas_used" , BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |) |) in let _ := M.assign_local (| "gas_refund" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ BinOp.floor_div (| - M.get_name (| globals, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_used" |), Constant.int 2 |); - M.get_field (| M.get_name (| globals, "output" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "refund_counter" |) ], make_dict [] |) @@ -1703,10 +1717,10 @@ Definition process_transaction : Value.t -> Value.t -> M := "gas_refund_amount" , BinOp.mult (| BinOp.add (| - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |), - M.get_name (| globals, "gas_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| @@ -1714,41 +1728,41 @@ Definition process_transaction : Value.t -> Value.t -> M := BinOp.mult (| BinOp.sub (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "tx" |), "gas" |), - M.get_field (| M.get_name (| globals, "output" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "gas_left" |) |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_refund" |) |), - M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |) |) |) in let _ := M.assign_local (| "total_gas_used" , BinOp.sub (| - M.get_name (| globals, "gas_used" |), - M.get_name (| globals, "gas_refund" |) + M.get_name (| globals, locals_stack, "gas_used" |), + M.get_name (| globals, locals_stack, "gas_refund" |) |) |) in let _ := M.assign_local (| "sender_balance_after_refund" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "gas_refund_amount" |) + M.get_name (| globals, locals_stack, "gas_refund_amount" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "sender" |); - M.get_name (| globals, "sender_balance_after_refund" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender" |); + M.get_name (| globals, locals_stack, "sender_balance_after_refund" |) ], make_dict [] |) in @@ -1756,35 +1770,35 @@ Definition process_transaction : Value.t -> Value.t -> M := "coinbase_balance_after_mining_fee" , BinOp.add (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |) ], make_dict [] |), "balance" |), - M.get_name (| globals, "transaction_fee" |) + M.get_name (| globals, locals_stack, "transaction_fee" |) |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "env" |), "coinbase" |); - M.get_name (| globals, "coinbase_balance_after_mining_fee" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "coinbase" |); + M.get_name (| globals, locals_stack, "coinbase_balance_after_mining_fee" |) ], make_dict [] |) in let _ := M.for_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "output" |), "accounts_to_delete" |), + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "output" |), "accounts_to_delete" |), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "destroy_account" |), + M.get_name (| globals, locals_stack, "destroy_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in @@ -1795,13 +1809,14 @@ Definition process_transaction : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - make_tuple [ M.get_name (| globals, "total_gas_used" |); M.get_field (| M.get_name (| globals, "output" |), "logs" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "total_gas_used" |); M.get_field (| M.get_name (| globals, locals_stack, "output" |), "logs" |) ] |) in M.pure Constant.None_)). Definition validate_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Verifies a transaction. @@ -1830,17 +1845,17 @@ Definition validate_transaction : Value.t -> Value.t -> M := BoolOp.and (| Compare.lt_e (| M.call (| - M.get_name (| globals, "calculate_intrinsic_cost" |), + M.get_name (| globals, locals_stack, "calculate_intrinsic_cost" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |), - M.get_field (| M.get_name (| globals, "tx" |), "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_field (| M.get_name (| globals, "tx" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |), BinOp.sub (| BinOp.pow (| Constant.int 2, @@ -1855,8 +1870,9 @@ Definition validate_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas that is charged before execution is started. @@ -1885,14 +1901,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "byte" |), - M.get_field (| M.get_name (| globals, "tx" |), "data" |), + M.get_name (| globals, locals_stack, "byte" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 0 |), (* then *) @@ -1900,7 +1916,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_ZERO" |) |) in M.pure Constant.None_ (* else *) @@ -1908,7 +1924,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "data_cost", - M.get_name (| globals, "TX_DATA_COST_PER_NON_ZERO" |) + M.get_name (| globals, locals_stack, "TX_DATA_COST_PER_NON_ZERO" |) |) in M.pure Constant.None_ )) |) in @@ -1922,9 +1938,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "tx" |), "to" |), + M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -1935,7 +1951,7 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "create_cost" , - M.get_name (| globals, "TX_CREATE_COST" |) + M.get_name (| globals, locals_stack, "TX_CREATE_COST" |) |) in M.pure Constant.None_ (* else *) @@ -1948,14 +1964,14 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.add (| BinOp.add (| - M.get_name (| globals, "TX_BASE_COST" |), - M.get_name (| globals, "data_cost" |) + M.get_name (| globals, locals_stack, "TX_BASE_COST" |), + M.get_name (| globals, locals_stack, "data_cost" |) |), - M.get_name (| globals, "create_cost" |) + M.get_name (| globals, locals_stack, "create_cost" |) |) ], make_dict [] @@ -1964,8 +1980,9 @@ Definition calculate_intrinsic_cost : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition recover_sender : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Extracts the sender address from a transaction. @@ -1986,84 +2003,84 @@ Definition recover_sender : Value.t -> Value.t -> M := The address of the account that signed the transaction. " in let _ := M.assign (| - make_tuple [ M.get_name (| globals, "v" |); M.get_name (| globals, "r" |); M.get_name (| globals, "s" |) ], - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "v" |); M.get_field (| M.get_name (| globals, "tx" |), "r" |); M.get_field (| M.get_name (| globals, "tx" |), "s" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "v" |); M.get_name (| globals, locals_stack, "r" |); M.get_name (| globals, locals_stack, "s" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "v" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "r" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "s" |) ] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.or (| Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.lt (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ BoolOp.and (| Compare.lt (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_name (| globals, "s" |), + M.get_name (| globals, locals_stack, "s" |), BinOp.floor_div (| - M.get_name (| globals, "SECP256K1N" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |), Constant.int 2 |) |) )) |); - M.get_name (| globals, "InvalidBlock" |) + M.get_name (| globals, locals_stack, "InvalidBlock" |) ], make_dict [] |) in let _ := M.assign_local (| "public_key" , M.call (| - M.get_name (| globals, "secp256k1_recover" |), + M.get_name (| globals, locals_stack, "secp256k1_recover" |), make_list [ - M.get_name (| globals, "r" |); - M.get_name (| globals, "s" |); + M.get_name (| globals, locals_stack, "r" |); + M.get_name (| globals, locals_stack, "s" |); BinOp.sub (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |); M.call (| - M.get_name (| globals, "signing_hash" |), + M.get_name (| globals, locals_stack, "signing_hash" |), make_list [ - M.get_name (| globals, "tx" |) + M.get_name (| globals, locals_stack, "tx" |) ], make_dict [] |) @@ -2073,13 +2090,13 @@ Definition recover_sender : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -2094,8 +2111,9 @@ Definition recover_sender : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition signing_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "tx" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "tx" ] in + ltac:(M.monadic ( let _ := Constant.str " Compute the hash of a transaction used in the signature. @@ -2115,12 +2133,12 @@ Definition signing_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, "tx" |), "to" |); M.get_field (| M.get_name (| globals, "tx" |), "value" |); M.get_field (| M.get_name (| globals, "tx" |), "data" |) ] + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas_price" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "gas" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "to" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "value" |); M.get_field (| M.get_name (| globals, locals_stack, "tx" |), "data" |) ] ], make_dict [] |) @@ -2131,8 +2149,9 @@ Definition signing_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_header_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "header" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "header" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the hash of a block header. @@ -2166,12 +2185,12 @@ Definition compute_header_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "header" |) + M.get_name (| globals, locals_stack, "header" |) ], make_dict [] |) @@ -2182,8 +2201,9 @@ Definition compute_header_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition check_gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas_limit"; "parent_gas_limit" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas_limit"; "parent_gas_limit" ] in + ltac:(M.monadic ( let _ := Constant.str " Validates the gas limit for a block. @@ -2214,18 +2234,18 @@ Definition check_gas_limit : Value.t -> Value.t -> M := let _ := M.assign_local (| "max_adjustment_delta" , BinOp.floor_div (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_ADJUSTMENT_FACTOR" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.add (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2242,10 +2262,10 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "gas_limit" |), + M.get_name (| globals, locals_stack, "gas_limit" |), BinOp.sub (| - M.get_name (| globals, "parent_gas_limit" |), - M.get_name (| globals, "max_adjustment_delta" |) + M.get_name (| globals, locals_stack, "parent_gas_limit" |), + M.get_name (| globals, locals_stack, "max_adjustment_delta" |) |) |), (* then *) @@ -2262,8 +2282,8 @@ Definition check_gas_limit : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_limit" |), - M.get_name (| globals, "GAS_LIMIT_MINIMUM" |) + M.get_name (| globals, locals_stack, "gas_limit" |), + M.get_name (| globals, locals_stack, "GAS_LIMIT_MINIMUM" |) |), (* then *) ltac:(M.monadic ( @@ -2281,8 +2301,9 @@ Definition check_gas_limit : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_block_difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "block_number"; "block_timestamp"; "parent_timestamp"; "parent_difficulty" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes difficulty of a block using its header and parent header. @@ -2324,26 +2345,26 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.mult (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), Constant.int 2048 |), M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ BinOp.sub (| Constant.int 1, BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.sub (| - M.get_name (| globals, "block_timestamp" |), - M.get_name (| globals, "parent_timestamp" |) + M.get_name (| globals, locals_stack, "block_timestamp" |), + M.get_name (| globals, locals_stack, "parent_timestamp" |) |) ], make_dict [] @@ -2361,13 +2382,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty" , BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "parent_difficulty" |) + M.get_name (| globals, locals_stack, "parent_difficulty" |) ], make_dict [] |), - M.get_name (| globals, "offset" |) + M.get_name (| globals, locals_stack, "offset" |) |) |) in let _ := M.assign_local (| @@ -2375,9 +2396,9 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := BinOp.sub (| BinOp.floor_div (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "block_number" |) + M.get_name (| globals, locals_stack, "block_number" |) ], make_dict [] |), @@ -2390,7 +2411,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "num_bomb_periods" |), + M.get_name (| globals, locals_stack, "num_bomb_periods" |), Constant.int 0 |), (* then *) @@ -2400,7 +2421,7 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := "difficulty", BinOp.pow (| Constant.int 2, - M.get_name (| globals, "num_bomb_periods" |) + M.get_name (| globals, locals_stack, "num_bomb_periods" |) |) |) in M.pure Constant.None_ @@ -2410,13 +2431,13 @@ Definition calculate_block_difficulty : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "max" |), + M.get_name (| globals, locals_stack, "max" |), make_list [ - M.get_name (| globals, "difficulty" |); - M.get_name (| globals, "MINIMUM_DIFFICULTY" |) + M.get_name (| globals, locals_stack, "difficulty" |); + M.get_name (| globals, locals_stack, "MINIMUM_DIFFICULTY" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/fork_types.v b/CoqOfPython/ethereum/tangerine_whistle/fork_types.v index d749dca..76d92b0 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/fork_types.v +++ b/CoqOfPython/ethereum/tangerine_whistle/fork_types.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.fork_types". +Definition globals : Globals.t := "ethereum.tangerine_whistle.fork_types". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,15 +44,15 @@ Axiom ethereum_crypto_hash_imports_keccak256 : IsImported globals "ethereum.crypto.hash" "keccak256". Definition Address : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes20" |) + M.get_name (| globals, locals_stack, "Bytes20" |) )). Definition Root : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Hash32" |) + M.get_name (| globals, locals_stack, "Hash32" |) )). Definition Bloom : Value.t := M.run ltac:(M.monadic ( - M.get_name (| globals, "Bytes256" |) + M.get_name (| globals, locals_stack, "Bytes256" |) )). Definition Account : Value.t := @@ -65,15 +67,16 @@ Definition Account : Value.t := Definition EMPTY_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Account" |), + M.get_name (| globals, locals_stack, "Account" |), make_list [], make_dict [] |) )). Definition encode_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "raw_account_data"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "raw_account_data"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode `Account` dataclass. @@ -82,12 +85,12 @@ Definition encode_account : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - make_tuple [ M.get_field (| M.get_name (| globals, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, "raw_account_data" |), "balance" |); M.get_name (| globals, "storage_root" |); M.call (| - M.get_name (| globals, "keccak256" |), + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "nonce" |); M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "balance" |); M.get_name (| globals, locals_stack, "storage_root" |); M.call (| + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_field (| M.get_name (| globals, "raw_account_data" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "raw_account_data" |), "code" |) ], make_dict [] |) ] diff --git a/CoqOfPython/ethereum/tangerine_whistle/state.v b/CoqOfPython/ethereum/tangerine_whistle/state.v index ffd4f3b..d94f612 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/state.v +++ b/CoqOfPython/ethereum/tangerine_whistle/state.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.state". +Definition globals : Globals.t := "ethereum.tangerine_whistle.state". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -83,20 +85,22 @@ Definition State : Value.t := ]. Definition close_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Free resources held by the state. Used by optimized implementations to release file descriptors. " in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) |) in - let _ := M.delete (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |) in + let _ := M.delete (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) in M.pure Constant.None_)). Definition begin_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Start a state transaction. @@ -109,12 +113,12 @@ Definition begin_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "append" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "append" |), make_list [ make_tuple [ M.call (| - M.get_name (| globals, "copy_trie" |), + M.get_name (| globals, locals_stack, "copy_trie" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |); Constant.str "(* At expr: unsupported node type: DictComp *)" ] @@ -124,8 +128,9 @@ Definition begin_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition commit_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Commit a state transaction. @@ -135,15 +140,16 @@ Definition commit_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) in M.pure Constant.None_)). Definition rollback_transaction : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Rollback a state transaction, resetting the state to the point when the corresponding `start_transaction()` call was made. @@ -154,9 +160,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := The state. " in let _ := M.assign (| - make_tuple [ M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) ], + make_tuple [ M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |), "pop" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |), "pop" |), make_list [], make_dict [] |) @@ -164,8 +170,9 @@ Definition rollback_transaction : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `EMPTY_ACCOUNT` if there is no account at the address. @@ -188,10 +195,10 @@ Definition get_account : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -200,31 +207,32 @@ Definition get_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "account" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "account" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition get_account_optional : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Get the `Account` object at an address. Returns `None` (rather than `EMPTY_ACCOUNT`) if there is no account at the address. @@ -244,22 +252,23 @@ Definition get_account_optional : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "account" |) + M.get_name (| globals, locals_stack, "account" |) |) in M.pure Constant.None_)). Definition set_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "account" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "account" ] in + ltac:(M.monadic ( let _ := Constant.str " Set the `Account` object at an address. Setting to `None` deletes the account (but not its storage, see `destroy_account()`). @@ -274,19 +283,20 @@ Definition set_account : Value.t -> Value.t -> M := Account to set at address. " in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "account" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "account" |) ], make_dict [] |) in M.pure Constant.None_)). Definition destroy_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the account at `address` and all of its storage. @@ -302,18 +312,18 @@ Definition destroy_account : Value.t -> Value.t -> M := Address of account to destroy. " in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); Constant.None_ ], make_dict [] @@ -321,8 +331,9 @@ Definition destroy_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition destroy_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Completely remove the storage at `address`. @@ -337,14 +348,14 @@ Definition destroy_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -354,8 +365,9 @@ Definition destroy_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition get_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Get a value at a storage key on an account. Returns `U256(0)` if the storage key has not been set previously. @@ -377,9 +389,9 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -388,14 +400,14 @@ Definition get_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -410,30 +422,31 @@ Definition get_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition set_storage : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Set a value at a storage key on an account. Setting to `U256(0)` deletes the key. @@ -451,10 +464,10 @@ Definition set_storage : Value.t -> Value.t -> M := " in let _ := M.assert (| Compare.is_not (| M.call (| - M.get_name (| globals, "trie_get" |), + M.get_name (| globals, locals_stack, "trie_get" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -463,9 +476,9 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), "get" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -474,7 +487,7 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "trie" |), + M.get_name (| globals, locals_stack, "trie" |), Constant.None_ |), (* then *) @@ -482,17 +495,17 @@ Definition set_storage : Value.t -> Value.t -> M := let _ := M.assign_local (| "trie" , M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [], make_dict [] |) |) in let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |), - M.get_name (| globals, "trie" |) + M.get_name (| globals, locals_stack, "trie" |) |) in M.pure Constant.None_ (* else *) @@ -500,11 +513,11 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "trie_set" |), + M.get_name (| globals, locals_stack, "trie_set" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in @@ -512,14 +525,14 @@ Definition set_storage : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), Constant.str "(* At expr: unsupported node type: Dict *)" |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) |) in M.pure Constant.None_ (* else *) @@ -529,8 +542,9 @@ Definition set_storage : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition storage_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the storage root of an account. @@ -546,23 +560,23 @@ Definition storage_root : Value.t -> Value.t -> M := root : `Root` Storage root of the account. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "address" |), - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |) + M.get_name (| globals, locals_stack, "address" |), + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "state" |), "_storage_tries" |), - M.get_name (| globals, "address" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_storage_tries" |), + M.get_name (| globals, locals_stack, "address" |) |) ], make_dict [] @@ -572,15 +586,16 @@ Definition storage_root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "EMPTY_TRIE_ROOT" |) + M.get_name (| globals, locals_stack, "EMPTY_TRIE_ROOT" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition state_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculate the state root. @@ -594,13 +609,13 @@ Definition state_root : Value.t -> Value.t -> M := root : `Root` The state root. " in - let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, "state" |), "_snapshots" |) |) |) in + let _ := M.assert (| UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_snapshots" |) |) |) in (* At stmt: unsupported node type: FunctionDef *) let _ := M.return_ (| M.call (| - M.get_name (| globals, "root" |), + M.get_name (| globals, locals_stack, "root" |), make_list [ - M.get_field (| M.get_name (| globals, "state" |), "_main_trie" |) + M.get_field (| M.get_name (| globals, locals_stack, "state" |), "_main_trie" |) ], make_dict [] |) @@ -608,8 +623,9 @@ Definition state_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_exists : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account exists in the state trie @@ -628,10 +644,10 @@ Definition account_exists : Value.t -> Value.t -> M := let _ := M.return_ (| Compare.is_not (| M.call (| - M.get_name (| globals, "get_account_optional" |), + M.get_name (| globals, locals_stack, "get_account_optional" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), @@ -641,8 +657,9 @@ Definition account_exists : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition account_has_code_or_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if an account has non zero nonce or non empty code @@ -662,10 +679,10 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.assign_local (| "account" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -673,9 +690,9 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := let _ := M.return_ (| BoolOp.or (| Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -684,7 +701,7 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "account" |), "code" |), + M.get_field (| M.get_name (| globals, locals_stack, "account" |), "code" |), Constant.bytes "" |) )) @@ -693,28 +710,29 @@ Definition account_has_code_or_nonce : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition modify_state : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "f" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "f" ] in + ltac:(M.monadic ( let _ := Constant.str " Modify an `Account` in the `State`. " in let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); M.call (| - M.get_name (| globals, "modify" |), + M.get_name (| globals, locals_stack, "modify" |), make_list [ M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |); - M.get_name (| globals, "f" |) + M.get_name (| globals, locals_stack, "f" |) ], make_dict [] |) @@ -724,36 +742,38 @@ Definition modify_state : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition move_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "sender_address"; "recipient_address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "sender_address"; "recipient_address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Move funds between accounts. " in (* At stmt: unsupported node type: FunctionDef *) (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "sender_address" |); - M.get_name (| globals, "reduce_sender_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "sender_address" |); + M.get_name (| globals, locals_stack, "reduce_sender_balance" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "recipient_address" |); - M.get_name (| globals, "increase_recipient_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "recipient_address" |); + M.get_name (| globals, locals_stack, "increase_recipient_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_account_balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets the balance of an account. @@ -770,19 +790,20 @@ Definition set_account_balance : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "set_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "set_balance" |) ], make_dict [] |) in M.pure Constant.None_)). Definition touch_account : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Initializes an account to state. @@ -798,21 +819,21 @@ Definition touch_account : Value.t -> Value.t -> M := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "set_account" |), + M.get_name (| globals, locals_stack, "set_account" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "EMPTY_ACCOUNT" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "EMPTY_ACCOUNT" |) ], make_dict [] |) in @@ -824,8 +845,9 @@ Definition touch_account : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition increment_nonce : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address" ] in + ltac:(M.monadic ( let _ := Constant.str " Increments the nonce of an account. @@ -839,19 +861,20 @@ Definition increment_nonce : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_nonce" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_nonce" |) ], make_dict [] |) in M.pure Constant.None_)). Definition set_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Sets Account code. @@ -868,19 +891,20 @@ Definition set_code : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "write_code" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "write_code" |) ], make_dict [] |) in M.pure Constant.None_)). Definition create_ether : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "state"; "address"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "state"; "address"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Add newly created ether to an account. @@ -895,11 +919,11 @@ Definition create_ether : Value.t -> Value.t -> M := " in (* At stmt: unsupported node type: FunctionDef *) let _ := M.call (| - M.get_name (| globals, "modify_state" |), + M.get_name (| globals, locals_stack, "modify_state" |), make_list [ - M.get_name (| globals, "state" |); - M.get_name (| globals, "address" |); - M.get_name (| globals, "increase_balance" |) + M.get_name (| globals, locals_stack, "state" |); + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "increase_balance" |) ], make_dict [] |) in diff --git a/CoqOfPython/ethereum/tangerine_whistle/transactions.v b/CoqOfPython/ethereum/tangerine_whistle/transactions.v index cfb821b..20fa717 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/transactions.v +++ b/CoqOfPython/ethereum/tangerine_whistle/transactions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.transactions". +Definition globals : Globals.t := "ethereum.tangerine_whistle.transactions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/tangerine_whistle/trie.v b/CoqOfPython/ethereum/tangerine_whistle/trie.v index 1390bd6..2e13011 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/trie.v +++ b/CoqOfPython/ethereum/tangerine_whistle/trie.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.trie". +Definition globals : Globals.t := "ethereum.tangerine_whistle.trie". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -89,10 +91,10 @@ Axiom ethereum_tangerine_whistle_transactions_imports_Transaction : Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_name (| globals, "hex_to_bytes" |), + M.get_name (| globals, locals_stack, "hex_to_bytes" |), make_list [ Constant.str "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421" ], @@ -105,14 +107,14 @@ Definition EMPTY_TRIE_ROOT : Value.t := M.run ltac:(M.monadic ( Definition Node : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Bytes" |); M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |); M.get_name (| globals, "U256" |); Constant.None_ ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Bytes" |); M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |); M.get_name (| globals, locals_stack, "U256" |); Constant.None_ ] |) )). Definition K : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "K" ], @@ -122,28 +124,28 @@ Definition K : Value.t := M.run ltac:(M.monadic ( Definition V : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "TypeVar" |), + M.get_name (| globals, locals_stack, "TypeVar" |), make_list [ Constant.str "V"; M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Account" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Bytes" |) |); - M.get_name (| globals, "Bytes" |); + M.get_name (| globals, locals_stack, "Bytes" |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Transaction" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Transaction" |) |); M.get_subscript (| - M.get_name (| globals, "Optional" |), - M.get_name (| globals, "Receipt" |) + M.get_name (| globals, locals_stack, "Optional" |), + M.get_name (| globals, locals_stack, "Receipt" |) |); - M.get_name (| globals, "Uint" |); - M.get_name (| globals, "U256" |) + M.get_name (| globals, locals_stack, "Uint" |); + M.get_name (| globals, locals_stack, "U256" |) ], make_dict [] |) @@ -181,14 +183,15 @@ Definition BranchNode : Value.t := Definition InternalNode : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "LeafNode" |); M.get_name (| globals, "ExtensionNode" |); M.get_name (| globals, "BranchNode" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "LeafNode" |); M.get_name (| globals, locals_stack, "ExtensionNode" |); M.get_name (| globals, locals_stack, "BranchNode" |) ] |) )). Definition encode_internal_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node" ] in + ltac:(M.monadic ( let _ := Constant.str " Encodes a Merkle Trie node into its RLP form. The RLP will then be serialized into a `Bytes` and hashed unless it is less that 32 bytes @@ -212,7 +215,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "node" |), + M.get_name (| globals, locals_stack, "node" |), Constant.None_ |), (* then *) @@ -228,10 +231,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "LeafNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "LeafNode" |) ], make_dict [] |), @@ -240,13 +243,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "rest_of_key" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "rest_of_key" |); Constant.bool true ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "value" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) in M.pure Constant.None_ (* else *) @@ -255,10 +258,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "ExtensionNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "ExtensionNode" |) ], make_dict [] |), @@ -267,13 +270,13 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , make_tuple [ M.call (| - M.get_name (| globals, "nibble_list_to_compact" |), + M.get_name (| globals, locals_stack, "nibble_list_to_compact" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "key_segment" |); + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "key_segment" |); Constant.bool false ], make_dict [] - |); M.get_field (| M.get_name (| globals, "node" |), "subnode" |) ] + |); M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnode" |) ] |) in M.pure Constant.None_ (* else *) @@ -282,10 +285,10 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "BranchNode" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "BranchNode" |) ], make_dict [] |), @@ -294,9 +297,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "unencoded" , BinOp.add (| - M.get_field (| M.get_name (| globals, "node" |), "subnodes" |), + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "subnodes" |), make_list [ - M.get_field (| M.get_name (| globals, "node" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "node" |), "value" |) ] |) |) in @@ -304,7 +307,7 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "(* At expr: unsupported node type: JoinedStr *)" ], @@ -321,9 +324,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded" , M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) ], make_dict [] |) @@ -333,9 +336,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |), @@ -344,16 +347,16 @@ Definition encode_internal_node : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "unencoded" |) + M.get_name (| globals, locals_stack, "unencoded" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "encoded" |) + M.get_name (| globals, locals_stack, "encoded" |) ], make_dict [] |) @@ -363,8 +366,9 @@ Definition encode_internal_node : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition encode_node : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "node"; "storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "node"; "storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Encode a Node for storage in the Merkle Trie. @@ -374,25 +378,25 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "storage_root" |), + M.get_name (| globals, locals_stack, "storage_root" |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "encode_account" |), + M.get_name (| globals, locals_stack, "encode_account" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -404,10 +408,10 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - make_tuple [ M.get_name (| globals, "Transaction" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "U256" |) ] + M.get_name (| globals, locals_stack, "node" |); + make_tuple [ M.get_name (| globals, locals_stack, "Transaction" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "U256" |) ] ], make_dict [] |), @@ -415,13 +419,13 @@ Definition encode_node : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ M.call (| - M.get_name (| globals, "cast" |), + M.get_name (| globals, locals_stack, "cast" |), make_list [ - M.get_field (| M.get_name (| globals, "rlp" |), "RLP" |); - M.get_name (| globals, "node" |) + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "RLP" |); + M.get_name (| globals, locals_stack, "node" |) ], make_dict [] |) @@ -436,27 +440,27 @@ Definition encode_node : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "node" |) + M.get_name (| globals, locals_stack, "node" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "previous_trie" |), "encode_node" |), + M.get_field (| M.get_name (| globals, locals_stack, "previous_trie" |), "encode_node" |), make_list [ - M.get_name (| globals, "node" |); - M.get_name (| globals, "storage_root" |) + M.get_name (| globals, locals_stack, "node" |); + M.get_name (| globals, locals_stack, "storage_root" |) ], make_dict [] |) @@ -480,8 +484,9 @@ Definition Trie : Value.t := ]. Definition copy_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a copy of `trie`. Since only frozen objects may be stored in tries, the contents are reused. @@ -498,14 +503,14 @@ Definition copy_trie : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Trie" |), + M.get_name (| globals, locals_stack, "Trie" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "secured" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |); M.call (| - M.get_field (| M.get_name (| globals, "copy" |), "copy" |), + M.get_field (| M.get_name (| globals, locals_stack, "copy" |), "copy" |), make_list [ - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) ], make_dict [] |) @@ -516,8 +521,9 @@ Definition copy_trie : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition trie_set : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores an item in a Merkle Trie. @@ -537,8 +543,8 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) |), (* then *) ltac:(M.monadic ( @@ -546,14 +552,14 @@ Definition trie_set : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.in_ (| - M.get_name (| globals, "key" |), - M.get_field (| M.get_name (| globals, "trie" |), "_data" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |) |), (* then *) ltac:(M.monadic ( let _ := M.delete (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ (* else *) @@ -565,18 +571,19 @@ Definition trie_set : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_field (| M.get_name (| globals, "trie" |), "_data" |), - M.get_name (| globals, "key" |) + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), + M.get_name (| globals, locals_stack, "key" |) |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_)). Definition trie_get : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "key" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "key" ] in + ltac:(M.monadic ( let _ := Constant.str " Gets an item from the Merkle Trie. @@ -596,10 +603,10 @@ Definition trie_get : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "get" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "get" |), make_list [ - M.get_name (| globals, "key" |); - M.get_field (| M.get_name (| globals, "trie" |), "default" |) + M.get_name (| globals, locals_stack, "key" |); + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "default" |) ], make_dict [] |) @@ -607,21 +614,22 @@ Definition trie_get : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition common_prefix_length : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "a"; "b" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "a"; "b" ] in + ltac:(M.monadic ( let _ := Constant.str " Find the longest common prefix of two sequences. " in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -634,11 +642,11 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.gt_e (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "b" |) + M.get_name (| globals, locals_stack, "b" |) ], make_dict [] |) @@ -646,12 +654,12 @@ Definition common_prefix_length : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.not_eq (| M.get_subscript (| - M.get_name (| globals, "a" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "a" |), + M.get_name (| globals, locals_stack, "i" |) |), M.get_subscript (| - M.get_name (| globals, "b" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "b" |), + M.get_name (| globals, locals_stack, "i" |) |) |) )) @@ -659,7 +667,7 @@ Definition common_prefix_length : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "i" |) |) in M.pure Constant.None_ (* else *) @@ -674,9 +682,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "a" |) + M.get_name (| globals, locals_stack, "a" |) ], make_dict [] |) @@ -684,8 +692,9 @@ Definition common_prefix_length : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition nibble_list_to_compact : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "x"; "is_leaf" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "x"; "is_leaf" ] in + ltac:(M.monadic ( let _ := Constant.str " Compresses nibble-list into a standard byte array with a flag. @@ -722,7 +731,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := let _ := M.assign_local (| "compact" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [], make_dict [] |) @@ -733,9 +742,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := Compare.eq (| BinOp.mod_ (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), @@ -746,13 +755,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.mult (| Constant.int 16, BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |) |) ], @@ -760,15 +769,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -778,20 +787,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -809,7 +818,7 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| @@ -817,13 +826,13 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := BinOp.add (| BinOp.mult (| Constant.int 2, - M.get_name (| globals, "is_leaf" |) + M.get_name (| globals, locals_stack, "is_leaf" |) |), Constant.int 1 |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) |) @@ -832,15 +841,15 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 1; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |); @@ -850,20 +859,20 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "compact" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "compact" |), "append" |), make_list [ BinOp.add (| BinOp.mult (| Constant.int 16, M.get_subscript (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "i" |) |) |), M.get_subscript (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 1 |) |) @@ -881,9 +890,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "compact" |) + M.get_name (| globals, locals_stack, "compact" |) ], make_dict [] |) @@ -891,8 +900,9 @@ Definition nibble_list_to_compact : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition bytes_to_nibble_list : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "bytes_" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "bytes_" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a `Bytes` into to a sequence of nibbles (bytes with value < 16). @@ -909,14 +919,14 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := let _ := M.assign_local (| "nibble_list" , M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| Constant.int 2, M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |) @@ -927,26 +937,26 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "byte_index" |); M.get_name (| globals, "byte" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "byte_index" |); M.get_name (| globals, locals_stack, "byte" |) ], M.call (| - M.get_name (| globals, "enumerate" |), + M.get_name (| globals, locals_stack, "enumerate" |), make_list [ - M.get_name (| globals, "bytes_" |) + M.get_name (| globals, locals_stack, "bytes_" |) ], make_dict [] |), ltac:(M.monadic ( let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |) |), BinOp.r_shift (| BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 240 |), Constant.int 4 @@ -954,17 +964,17 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "nibble_list" |), + M.get_name (| globals, locals_stack, "nibble_list" |), BinOp.add (| BinOp.mult (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 2 |), Constant.int 1 |) |), BinOp.bit_and (| - M.get_name (| globals, "byte" |), + M.get_name (| globals, locals_stack, "byte" |), Constant.int 15 |) |) in @@ -976,9 +986,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ - M.get_name (| globals, "nibble_list" |) + M.get_name (| globals, locals_stack, "nibble_list" |) ], make_dict [] |) @@ -986,8 +996,9 @@ Definition bytes_to_nibble_list : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition _prepare_trie : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Prepares the trie for root calculation. Removes values that are empty, hashes the keys (if `secured == True`) and encodes all the nodes. @@ -1008,9 +1019,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "preimage" |); M.get_name (| globals, "value" |) ], + make_tuple [ M.get_name (| globals, locals_stack, "preimage" |); M.get_name (| globals, locals_stack, "value" |) ], M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "trie" |), "_data" |), "items" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "_data" |), "items" |), make_list [], make_dict [] |), @@ -1019,25 +1030,25 @@ Definition _prepare_trie : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "Account" |) + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "Account" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.assert (| Compare.is_not (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), Constant.None_ |) |) in let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1045,13 +1056,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |); + M.get_name (| globals, locals_stack, "value" |); M.call (| - M.get_name (| globals, "get_storage_root" |), + M.get_name (| globals, locals_stack, "get_storage_root" |), make_list [ - M.get_name (| globals, "address" |) + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |) @@ -1065,9 +1076,9 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := M.assign_local (| "encoded_value" , M.call (| - M.get_name (| globals, "encode_node" |), + M.get_name (| globals, locals_stack, "encode_node" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -1075,13 +1086,13 @@ Definition _prepare_trie : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.not_eq (| - M.get_name (| globals, "encoded_value" |), + M.get_name (| globals, locals_stack, "encoded_value" |), Constant.bytes "" |); - M.get_name (| globals, "AssertionError" |) + M.get_name (| globals, locals_stack, "AssertionError" |) ], make_dict [] |) in @@ -1089,15 +1100,15 @@ Definition _prepare_trie : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "trie" |), "secured" |), + M.get_field (| M.get_name (| globals, locals_stack, "trie" |), "secured" |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "key" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) ], make_dict [] |) @@ -1107,22 +1118,22 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "key" , - M.get_name (| globals, "preimage" |) + M.get_name (| globals, locals_stack, "preimage" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| M.get_subscript (| - M.get_name (| globals, "mapped" |), + M.get_name (| globals, locals_stack, "mapped" |), M.call (| - M.get_name (| globals, "bytes_to_nibble_list" |), + M.get_name (| globals, locals_stack, "bytes_to_nibble_list" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |), - M.get_name (| globals, "encoded_value" |) + M.get_name (| globals, locals_stack, "encoded_value" |) |) in M.pure Constant.None_ )), @@ -1131,13 +1142,14 @@ Definition _prepare_trie : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "mapped" |) + M.get_name (| globals, locals_stack, "mapped" |) |) in M.pure Constant.None_)). Definition root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "trie"; "get_storage_root" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "trie"; "get_storage_root" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes the root of a modified merkle patricia trie (MPT). @@ -1158,10 +1170,10 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "obj" , M.call (| - M.get_name (| globals, "_prepare_trie" |), + M.get_name (| globals, locals_stack, "_prepare_trie" |), make_list [ - M.get_name (| globals, "trie" |); - M.get_name (| globals, "get_storage_root" |) + M.get_name (| globals, locals_stack, "trie" |); + M.get_name (| globals, locals_stack, "get_storage_root" |) ], make_dict [] |) @@ -1169,14 +1181,14 @@ Definition root : Value.t -> Value.t -> M := let _ := M.assign_local (| "root_node" , M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1194,12 +1206,12 @@ Definition root : Value.t -> Value.t -> M := M.if_then_else (| Compare.lt (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1212,12 +1224,12 @@ Definition root : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1229,18 +1241,18 @@ Definition root : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.assert (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "root_node" |); - M.get_name (| globals, "Bytes" |) + M.get_name (| globals, locals_stack, "root_node" |); + M.get_name (| globals, locals_stack, "Bytes" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ - M.get_name (| globals, "root_node" |) + M.get_name (| globals, locals_stack, "root_node" |) ], make_dict [] |) @@ -1250,8 +1262,9 @@ Definition root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition patricialize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "obj"; "level" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "obj"; "level" ] in + ltac:(M.monadic ( let _ := Constant.str " Structural composition function. @@ -1275,9 +1288,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1296,12 +1309,12 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "arbitrary_key" , M.call (| - M.get_name (| globals, "next" |), + M.get_name (| globals, locals_stack, "next" |), make_list [ M.call (| - M.get_name (| globals, "iter" |), + M.get_name (| globals, locals_stack, "iter" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |) @@ -1314,9 +1327,9 @@ Definition patricialize : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "obj" |) + M.get_name (| globals, locals_stack, "obj" |) ], make_dict [] |), @@ -1327,24 +1340,24 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "leaf" , M.call (| - M.get_name (| globals, "LeafNode" |), + M.get_name (| globals, locals_stack, "LeafNode" |), make_list [ M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |); M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "arbitrary_key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |) |) ], make_dict [] |) |) in let _ := M.return_ (| - M.get_name (| globals, "leaf" |) + M.get_name (| globals, locals_stack, "leaf" |) |) in M.pure Constant.None_ (* else *) @@ -1354,8 +1367,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "substring" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1363,31 +1376,31 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "substring" |) + M.get_name (| globals, locals_stack, "substring" |) ], make_dict [] |) |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := M.assign_local (| "prefix_length" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "prefix_length" |); + M.get_name (| globals, locals_stack, "prefix_length" |); M.call (| - M.get_name (| globals, "common_prefix_length" |), + M.get_name (| globals, locals_stack, "common_prefix_length" |), make_list [ - M.get_name (| globals, "substring" |); + M.get_name (| globals, locals_stack, "substring" |); M.slice (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |), Constant.None_, Constant.None_ |) @@ -1402,7 +1415,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1423,7 +1436,7 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "prefix_length" |), + M.get_name (| globals, locals_stack, "prefix_length" |), Constant.int 0 |), (* then *) @@ -1431,30 +1444,30 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "prefix" , M.slice (| - M.get_name (| globals, "arbitrary_key" |), - M.get_name (| globals, "level" |), + M.get_name (| globals, locals_stack, "arbitrary_key" |), + M.get_name (| globals, locals_stack, "level" |), BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |), Constant.None_ |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtensionNode" |), + M.get_name (| globals, locals_stack, "ExtensionNode" |), make_list [ - M.get_name (| globals, "prefix" |); + M.get_name (| globals, locals_stack, "prefix" |); M.call (| - M.get_name (| globals, "encode_internal_node" |), + M.get_name (| globals, locals_stack, "encode_internal_node" |), make_list [ M.call (| - M.get_name (| globals, "patricialize" |), + M.get_name (| globals, locals_stack, "patricialize" |), make_list [ - M.get_name (| globals, "obj" |); + M.get_name (| globals, locals_stack, "obj" |); BinOp.add (| - M.get_name (| globals, "level" |), - M.get_name (| globals, "prefix_length" |) + M.get_name (| globals, locals_stack, "level" |), + M.get_name (| globals, locals_stack, "prefix_length" |) |) ], make_dict [] @@ -1474,9 +1487,9 @@ Definition patricialize : Value.t -> Value.t -> M := (* At stmt: unsupported node type: AnnAssign *) let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 16 ], @@ -1484,7 +1497,7 @@ Definition patricialize : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "branches" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "branches" |), "append" |), make_list [ Constant.str "(* At expr: unsupported node type: Dict *)" ], @@ -1502,21 +1515,21 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "obj" |), + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "obj" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "level" |) |), (* then *) ltac:(M.monadic ( @@ -1524,19 +1537,19 @@ Definition patricialize : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |); - make_tuple [ M.get_name (| globals, "Account" |); M.get_name (| globals, "Receipt" |); M.get_name (| globals, "Uint" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "Account" |); M.get_name (| globals, locals_stack, "Receipt" |); M.get_name (| globals, locals_stack, "Uint" |) ] ], make_dict [] |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "AssertionError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "AssertionError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -1545,8 +1558,8 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1555,17 +1568,17 @@ Definition patricialize : Value.t -> Value.t -> M := let _ := M.assign (| M.get_subscript (| M.get_subscript (| - M.get_name (| globals, "branches" |), + M.get_name (| globals, locals_stack, "branches" |), M.get_subscript (| - M.get_name (| globals, "key" |), - M.get_name (| globals, "level" |) + M.get_name (| globals, locals_stack, "key" |), + M.get_name (| globals, locals_stack, "level" |) |) |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "key" |) |), M.get_subscript (| - M.get_name (| globals, "obj" |), - M.get_name (| globals, "key" |) + M.get_name (| globals, locals_stack, "obj" |), + M.get_name (| globals, locals_stack, "key" |) |) |) in M.pure Constant.None_ @@ -1578,10 +1591,10 @@ Definition patricialize : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "BranchNode" |), + M.get_name (| globals, locals_stack, "BranchNode" |), make_list [ Constant.str "(* At expr: unsupported node type: ListComp *)"; - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/utils/__init__.v b/CoqOfPython/ethereum/tangerine_whistle/utils/__init__.v index c4428f6..d60c8ff 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/utils/__init__.v +++ b/CoqOfPython/ethereum/tangerine_whistle/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.utils.__init__". +Definition globals : Globals.t := "ethereum.tangerine_whistle.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/tangerine_whistle/utils/address.v b/CoqOfPython/ethereum/tangerine_whistle/utils/address.v index e130a74..53b2410 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/utils/address.v +++ b/CoqOfPython/ethereum/tangerine_whistle/utils/address.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.utils.address". +Definition globals : Globals.t := "ethereum.tangerine_whistle.utils.address". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_tangerine_whistle_fork_types_imports_Address : IsImported globals "ethereum.tangerine_whistle.fork_types" "Address". Definition to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert a Uint or U256 value to a valid address (20 bytes). @@ -56,11 +59,11 @@ Definition to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.slice (| M.call (| - M.get_field (| M.get_name (| globals, "data" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "data" |), "to_be_bytes32" |), make_list [], make_dict [] |), @@ -75,8 +78,9 @@ Definition to_address : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition compute_contract_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "address"; "nonce" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "address"; "nonce" ] in + ltac:(M.monadic ( let _ := Constant.str " Computes address of the new account that needs to be created. @@ -96,14 +100,14 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "computed_address" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "rlp" |), "encode" |), + M.get_field (| M.get_name (| globals, locals_stack, "rlp" |), "encode" |), make_list [ make_list [ - M.get_name (| globals, "address" |); - M.get_name (| globals, "nonce" |) + M.get_name (| globals, locals_stack, "address" |); + M.get_name (| globals, locals_stack, "nonce" |) ] ], make_dict [] @@ -115,7 +119,7 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "canonical_address" , M.slice (| - M.get_name (| globals, "computed_address" |), + M.get_name (| globals, locals_stack, "computed_address" |), UnOp.sub (| Constant.int 20 |), Constant.None_, Constant.None_ @@ -124,9 +128,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "canonical_address" |); + M.get_name (| globals, locals_stack, "canonical_address" |); Constant.int 20 ], make_dict [] @@ -134,9 +138,9 @@ Definition compute_contract_address : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ - M.get_name (| globals, "padded_address" |) + M.get_name (| globals, locals_stack, "padded_address" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/utils/hexadecimal.v b/CoqOfPython/ethereum/tangerine_whistle/utils/hexadecimal.v index 0079ced..d556869 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/tangerine_whistle/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.tangerine_whistle.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_tangerine_whistle_fork_types_imports_Root : IsImported globals "ethereum.tangerine_whistle.fork_types" "Root". Definition hex_to_root : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to trie root. @@ -46,15 +49,15 @@ Definition hex_to_root : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Root" |), + M.get_name (| globals, locals_stack, "Root" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -68,8 +71,9 @@ Definition hex_to_root : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bloom : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bloom. @@ -85,15 +89,15 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bloom" |), + M.get_name (| globals, locals_stack, "Bloom" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -107,8 +111,9 @@ Definition hex_to_bloom : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Address (20 bytes). @@ -124,16 +129,16 @@ Definition hex_to_address : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Address" |), + M.get_name (| globals, locals_stack, "Address" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), diff --git a/CoqOfPython/ethereum/tangerine_whistle/utils/message.v b/CoqOfPython/ethereum/tangerine_whistle/utils/message.v index 8382bfd..d1df2f2 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/utils/message.v +++ b/CoqOfPython/ethereum/tangerine_whistle/utils/message.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.utils.message". +Definition globals : Globals.t := "ethereum.tangerine_whistle.utils.message". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_tangerine_whistle_utils_address_imports_compute_contract_address IsImported globals "ethereum.tangerine_whistle.utils.address" "compute_contract_address". Definition prepare_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "caller"; "target"; "value"; "data"; "gas"; "env"; "code_address"; "should_transfer_value" ] in + ltac:(M.monadic ( let _ := Constant.str " Execute a transaction against the provided environment. @@ -82,10 +85,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Bytes0" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Bytes0" |) ], make_dict [] |), @@ -94,20 +97,20 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_target" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_name (| globals, "caller" |); + M.get_name (| globals, locals_stack, "caller" |); BinOp.sub (| M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "caller" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "caller" |) ], make_dict [] |), "nonce" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -121,7 +124,7 @@ Definition prepare_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "msg_data" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ Constant.bytes "" ], @@ -130,7 +133,7 @@ Definition prepare_message : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "code" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_ (* else *) @@ -139,10 +142,10 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "isinstance" |), + M.get_name (| globals, locals_stack, "isinstance" |), make_list [ - M.get_name (| globals, "target" |); - M.get_name (| globals, "Address" |) + M.get_name (| globals, locals_stack, "target" |); + M.get_name (| globals, locals_stack, "Address" |) ], make_dict [] |), @@ -150,19 +153,19 @@ Definition prepare_message : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "current_target" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in let _ := M.assign_local (| "msg_data" , - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_name (| globals, "target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_name (| globals, locals_stack, "target" |) ], make_dict [] |), "code" |) @@ -171,14 +174,14 @@ Definition prepare_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.is (| - M.get_name (| globals, "code_address" |), + M.get_name (| globals, locals_stack, "code_address" |), Constant.None_ |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "code_address" , - M.get_name (| globals, "target" |) + M.get_name (| globals, locals_stack, "target" |) |) in M.pure Constant.None_ (* else *) @@ -189,7 +192,7 @@ Definition prepare_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "AssertionError" |), + M.get_name (| globals, locals_stack, "AssertionError" |), make_list [ Constant.str "Target must be address or empty bytes" ], @@ -201,7 +204,7 @@ Definition prepare_message : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/__init__.v b/CoqOfPython/ethereum/tangerine_whistle/vm/__init__.v index fb5763a..27b6aff 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/__init__.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.__init__". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -88,8 +90,9 @@ Definition Evm : Value.t := ]. Definition incorporate_child_on_success : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of a successful `child_evm` into the parent `evm`. @@ -102,31 +105,32 @@ Definition incorporate_child_on_success : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "logs" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "refund_counter" |) |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "update" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "accounts_to_delete" |) ], make_dict [] |) in M.pure Constant.None_)). Definition incorporate_child_on_error : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "child_evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "child_evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Incorporate the state of an unsuccessful `child_evm` into the parent `evm`. @@ -139,7 +143,7 @@ Definition incorporate_child_on_error : Value.t -> Value.t -> M := " in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "child_evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "gas_left" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/exceptions.v b/CoqOfPython/ethereum/tangerine_whistle/vm/exceptions.v index 97898c1..2f409fe 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/exceptions.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/exceptions.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.exceptions". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.exceptions". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -69,22 +71,23 @@ Definition InvalidOpcode : Value.t := [ ( "__init__", - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "self"; "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "self"; "code" ] in + ltac:(M.monadic ( let _ := M.call (| M.get_field (| M.call (| - M.get_name (| globals, "super" |), + M.get_name (| globals, locals_stack, "super" |), make_list [], make_dict [] |), "__init__" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "self" |), "code" |), - M.get_name (| globals, "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "self" |), "code" |), + M.get_name (| globals, locals_stack, "code" |) |) in M.pure Constant.None_)) ) diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/gas.v b/CoqOfPython/ethereum/tangerine_whistle/vm/gas.v index 716b689..82655cc 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/gas.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/gas.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.gas". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.gas". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -46,7 +48,7 @@ Axiom ethereum_tangerine_whistle_vm_exceptions_imports_OutOfGasError : Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 1 ], @@ -56,7 +58,7 @@ Definition GAS_JUMPDEST : Value.t := M.run ltac:(M.monadic ( Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2 ], @@ -66,7 +68,7 @@ Definition GAS_BASE : Value.t := M.run ltac:(M.monadic ( Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -76,7 +78,7 @@ Definition GAS_VERY_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -86,7 +88,7 @@ Definition GAS_SLOAD : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20000 ], @@ -96,7 +98,7 @@ Definition GAS_STORAGE_SET : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -106,7 +108,7 @@ Definition GAS_STORAGE_UPDATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15000 ], @@ -116,7 +118,7 @@ Definition GAS_STORAGE_CLEAR_REFUND : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5 ], @@ -126,7 +128,7 @@ Definition GAS_LOW : Value.t := M.run ltac:(M.monadic ( Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -136,7 +138,7 @@ Definition GAS_MID : Value.t := M.run ltac:(M.monadic ( Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -146,7 +148,7 @@ Definition GAS_HIGH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -156,7 +158,7 @@ Definition GAS_EXPONENTIATION : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 10 ], @@ -166,7 +168,7 @@ Definition GAS_EXPONENTIATION_PER_BYTE : Value.t := M.run ltac:(M.monadic ( Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -176,7 +178,7 @@ Definition GAS_MEMORY : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 30 ], @@ -186,7 +188,7 @@ Definition GAS_KECCAK256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 6 ], @@ -196,7 +198,7 @@ Definition GAS_KECCAK256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -206,7 +208,7 @@ Definition GAS_COPY : Value.t := M.run ltac:(M.monadic ( Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 20 ], @@ -216,7 +218,7 @@ Definition GAS_BLOCK_HASH : Value.t := M.run ltac:(M.monadic ( Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -226,7 +228,7 @@ Definition GAS_EXTERNAL : Value.t := M.run ltac:(M.monadic ( Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 400 ], @@ -236,7 +238,7 @@ Definition GAS_BALANCE : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -246,7 +248,7 @@ Definition GAS_LOG : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 8 ], @@ -256,7 +258,7 @@ Definition GAS_LOG_DATA : Value.t := M.run ltac:(M.monadic ( Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 375 ], @@ -266,7 +268,7 @@ Definition GAS_LOG_TOPIC : Value.t := M.run ltac:(M.monadic ( Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32000 ], @@ -276,7 +278,7 @@ Definition GAS_CREATE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 200 ], @@ -286,7 +288,7 @@ Definition GAS_CODE_DEPOSIT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -296,7 +298,7 @@ Definition GAS_ZERO : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 700 ], @@ -306,7 +308,7 @@ Definition GAS_CALL : Value.t := M.run ltac:(M.monadic ( Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -316,7 +318,7 @@ Definition GAS_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 9000 ], @@ -326,7 +328,7 @@ Definition GAS_CALL_VALUE : Value.t := M.run ltac:(M.monadic ( Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 2300 ], @@ -336,7 +338,7 @@ Definition GAS_CALL_STIPEND : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 5000 ], @@ -346,7 +348,7 @@ Definition GAS_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 25000 ], @@ -356,7 +358,7 @@ Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT : Value.t := M.run ltac:(M.monadic ( Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 24000 ], @@ -366,7 +368,7 @@ Definition REFUND_SELF_DESTRUCT : Value.t := M.run ltac:(M.monadic ( Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3000 ], @@ -376,7 +378,7 @@ Definition GAS_ECRECOVER : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 60 ], @@ -386,7 +388,7 @@ Definition GAS_SHA256 : Value.t := M.run ltac:(M.monadic ( Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 12 ], @@ -396,7 +398,7 @@ Definition GAS_SHA256_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 600 ], @@ -406,7 +408,7 @@ Definition GAS_RIPEMD160 : Value.t := M.run ltac:(M.monadic ( Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 120 ], @@ -416,7 +418,7 @@ Definition GAS_RIPEMD160_WORD : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 15 ], @@ -426,7 +428,7 @@ Definition GAS_IDENTITY : Value.t := M.run ltac:(M.monadic ( Definition GAS_IDENTITY_WORD : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 3 ], @@ -455,8 +457,9 @@ Definition MessageCallGas : Value.t := ]. Definition charge_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "amount" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "amount" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts `amount` from `evm.gas_left`. @@ -469,13 +472,13 @@ Definition charge_gas : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); M.call (| - M.get_name (| globals, "GasAndRefund" |), + M.get_name (| globals, locals_stack, "GasAndRefund" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -486,22 +489,22 @@ Definition charge_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "amount" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "amount" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "OutOfGasError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "OutOfGasError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "amount" |) + M.get_name (| globals, locals_stack, "amount" |) ], make_dict [] |) @@ -511,8 +514,9 @@ Definition charge_gas : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "size_in_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "size_in_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, @@ -532,9 +536,9 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := "size_in_words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "size_in_bytes" |) + M.get_name (| globals, locals_stack, "size_in_bytes" |) ], make_dict [] |), @@ -544,15 +548,15 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "linear_cost" , BinOp.mult (| - M.get_name (| globals, "size_in_words" |), - M.get_name (| globals, "GAS_MEMORY" |) + M.get_name (| globals, locals_stack, "size_in_words" |), + M.get_name (| globals, locals_stack, "GAS_MEMORY" |) |) |) in let _ := M.assign_local (| "quadratic_cost" , BinOp.floor_div (| BinOp.pow (| - M.get_name (| globals, "size_in_words" |), + M.get_name (| globals, locals_stack, "size_in_words" |), Constant.int 2 |), Constant.int 512 @@ -561,16 +565,17 @@ Definition calculate_memory_gas_cost : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_gas_cost" , BinOp.add (| - M.get_name (| globals, "linear_cost" |), - M.get_name (| globals, "quadratic_cost" |) + M.get_name (| globals, locals_stack, "linear_cost" |), + M.get_name (| globals, locals_stack, "quadratic_cost" |) |) |) in (* At stmt: unsupported node type: Try *) M.pure Constant.None_)). Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "extensions" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "extensions" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the gas amount to extend memory @@ -589,7 +594,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "size_to_extend" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -599,7 +604,7 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "to_be_paid" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -609,12 +614,12 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_size" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "memory" |) + M.get_name (| globals, locals_stack, "memory" |) ], make_dict [] |) @@ -624,14 +629,14 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - make_tuple [ M.get_name (| globals, "start_position" |); M.get_name (| globals, "size" |) ], - M.get_name (| globals, "extensions" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.get_name (| globals, locals_stack, "size" |) ], + M.get_name (| globals, locals_stack, "extensions" |), ltac:(M.monadic ( let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "size" |), + M.get_name (| globals, locals_stack, "size" |), Constant.int 0 |), (* then *) @@ -645,9 +650,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "before_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ - M.get_name (| globals, "current_size" |) + M.get_name (| globals, locals_stack, "current_size" |) ], make_dict [] |) @@ -655,20 +660,20 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "after_size" , M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -681,8 +686,8 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |), (* then *) ltac:(M.monadic ( @@ -696,16 +701,16 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "size_to_extend", BinOp.sub (| - M.get_name (| globals, "after_size" |), - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "after_size" |), + M.get_name (| globals, locals_stack, "before_size" |) |) |) in let _ := M.assign_local (| "already_paid" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "before_size" |) + M.get_name (| globals, locals_stack, "before_size" |) ], make_dict [] |) @@ -713,9 +718,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := let _ := M.assign_local (| "total_cost" , M.call (| - M.get_name (| globals, "calculate_memory_gas_cost" |), + M.get_name (| globals, locals_stack, "calculate_memory_gas_cost" |), make_list [ - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) ], make_dict [] |) @@ -724,13 +729,13 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := BinOp.add, "to_be_paid", BinOp.sub (| - M.get_name (| globals, "total_cost" |), - M.get_name (| globals, "already_paid" |) + M.get_name (| globals, locals_stack, "total_cost" |), + M.get_name (| globals, locals_stack, "already_paid" |) |) |) in let _ := M.assign_local (| "current_size" , - M.get_name (| globals, "after_size" |) + M.get_name (| globals, locals_stack, "after_size" |) |) in M.pure Constant.None_ )), @@ -740,10 +745,10 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "ExtendMemory" |), + M.get_name (| globals, locals_stack, "ExtendMemory" |), make_list [ - M.get_name (| globals, "to_be_paid" |); - M.get_name (| globals, "size_to_extend" |) + M.get_name (| globals, locals_stack, "to_be_paid" |); + M.get_name (| globals, locals_stack, "size_to_extend" |) ], make_dict [] |) @@ -751,8 +756,9 @@ Definition calculate_gas_extend_memory : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition calculate_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "gas"; "gas_left"; "memory_cost"; "extra_gas"; "call_stipend" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the MessageCallGas (cost and stipend) for executing call Opcodes. @@ -783,13 +789,13 @@ Definition calculate_message_call_gas : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -797,32 +803,32 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "call_stipend" |) +M.get_name (| globals, locals_stack, "call_stipend" |) )) |) |) in let _ := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "gas_left" |), + M.get_name (| globals, locals_stack, "gas_left" |), BinOp.add (| - M.get_name (| globals, "extra_gas" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "extra_gas" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |) |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -836,18 +842,18 @@ M.get_name (| globals, "call_stipend" |) let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ BinOp.sub (| BinOp.sub (| - M.get_name (| globals, "gas_left" |), - M.get_name (| globals, "memory_cost" |) + M.get_name (| globals, locals_stack, "gas_left" |), + M.get_name (| globals, locals_stack, "memory_cost" |) |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "extra_gas" |) |) ], make_dict [] @@ -858,15 +864,15 @@ M.get_name (| globals, "call_stipend" |) |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallGas" |), + M.get_name (| globals, locals_stack, "MessageCallGas" |), make_list [ BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "extra_gas" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "extra_gas" |) |); BinOp.add (| - M.get_name (| globals, "gas" |), - M.get_name (| globals, "call_stipend" |) + M.get_name (| globals, locals_stack, "gas" |), + M.get_name (| globals, locals_stack, "call_stipend" |) |) ], make_dict [] @@ -875,8 +881,9 @@ M.get_name (| globals, "call_stipend" |) M.pure Constant.None_)). Definition max_message_call_gas : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "gas" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "gas" ] in + ltac:(M.monadic ( let _ := Constant.str " Calculates the maximum gas that is allowed for making a message call @@ -892,9 +899,9 @@ Definition max_message_call_gas : Value.t -> Value.t -> M := " in let _ := M.return_ (| BinOp.sub (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), BinOp.floor_div (| - M.get_name (| globals, "gas" |), + M.get_name (| globals, locals_stack, "gas" |), Constant.int 64 |) |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/__init__.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/__init__.v index 22a0b88..6e8a81f 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/__init__.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.__init__". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/arithmetic.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/arithmetic.v index 6908f7e..ef45b8a 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/arithmetic.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.arithmetic". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -51,8 +53,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Adds the top two elements of the stack together, and pushes the result back on the stack. @@ -66,9 +69,9 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,49 +79,50 @@ Definition add : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_add" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_add" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sub : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Subtracts the top two elements of the stack, and pushes the result back on the stack. @@ -132,9 +136,9 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,49 +146,50 @@ Definition sub : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_sub" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_sub" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mul : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Multiply the top two elements of the stack, and pushes the result back on the stack. @@ -198,9 +203,9 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -208,49 +213,50 @@ Definition mul : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "x" |), "wrapping_mul" |), + M.get_field (| M.get_name (| globals, locals_stack, "x" |), "wrapping_mul" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition div : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -264,9 +270,9 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "dividend" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -274,18 +280,18 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "divisor" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -293,7 +299,7 @@ Definition div : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -301,7 +307,7 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -314,30 +320,31 @@ Definition div : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.floor_div (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "quotient" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sdiv : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed integer division of the top two elements of the stack. Pushes the result back on the stack. @@ -352,9 +359,9 @@ Definition sdiv : Value.t -> Value.t -> M := "dividend" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -366,9 +373,9 @@ Definition sdiv : Value.t -> Value.t -> M := "divisor" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -377,10 +384,10 @@ Definition sdiv : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -388,7 +395,7 @@ Definition sdiv : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), Constant.int 0 |), (* then *) @@ -405,12 +412,12 @@ Definition sdiv : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "dividend" |), - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + M.get_name (| globals, locals_stack, "dividend" |), + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "divisor" |), + M.get_name (| globals, locals_stack, "divisor" |), UnOp.sub (| Constant.int 1 |) |) )) @@ -419,7 +426,7 @@ Definition sdiv : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "quotient" , - UnOp.sub (| M.get_name (| globals, "U255_CEIL_VALUE" |) |) + UnOp.sub (| M.get_name (| globals, locals_stack, "U255_CEIL_VALUE" |) |) |) in M.pure Constant.None_ (* else *) @@ -427,11 +434,11 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "sign" , M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ BinOp.mult (| - M.get_name (| globals, "dividend" |), - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "dividend" |), + M.get_name (| globals, locals_stack, "divisor" |) |) ], make_dict [] @@ -440,19 +447,19 @@ Definition sdiv : Value.t -> Value.t -> M := let _ := M.assign_local (| "quotient" , BinOp.mult (| - M.get_name (| globals, "sign" |), + M.get_name (| globals, locals_stack, "sign" |), BinOp.floor_div (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "dividend" |) + M.get_name (| globals, locals_stack, "dividend" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "divisor" |) + M.get_name (| globals, locals_stack, "divisor" |) ], make_dict [] |) @@ -464,13 +471,13 @@ Definition sdiv : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "quotient" |) + M.get_name (| globals, locals_stack, "quotient" |) ], make_dict [] |) @@ -479,14 +486,15 @@ Definition sdiv : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mod_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -500,9 +508,9 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -510,18 +518,18 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -529,7 +537,7 @@ Definition mod_ : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -537,7 +545,7 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -550,30 +558,31 @@ Definition mod_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "remainder" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition smod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed modulo remainder of the top two elements of the stack. Pushes the result back on the stack. @@ -588,9 +597,9 @@ Definition smod : Value.t -> Value.t -> M := "x" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -602,9 +611,9 @@ Definition smod : Value.t -> Value.t -> M := "y" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -613,10 +622,10 @@ Definition smod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -624,7 +633,7 @@ Definition smod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "y" |), + M.get_name (| globals, locals_stack, "y" |), Constant.int 0 |), (* then *) @@ -640,24 +649,24 @@ Definition smod : Value.t -> Value.t -> M := "remainder" , BinOp.mult (| M.call (| - M.get_name (| globals, "get_sign" |), + M.get_name (| globals, locals_stack, "get_sign" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), BinOp.mod_ (| M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "x" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "abs" |), + M.get_name (| globals, locals_stack, "abs" |), make_list [ - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "y" |) ], make_dict [] |) @@ -667,13 +676,13 @@ Definition smod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_signed" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_signed" |), make_list [ - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) ], make_dict [] |) @@ -682,14 +691,15 @@ Definition smod : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition addmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo addition of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -703,12 +713,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -719,12 +729,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -735,12 +745,12 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -749,10 +759,10 @@ Definition addmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -760,7 +770,7 @@ Definition addmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -768,7 +778,7 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -781,14 +791,14 @@ Definition addmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.add (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -797,23 +807,24 @@ Definition addmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mulmod : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Modulo multiplication of the top 2 elements with the 3rd element. Pushes the result back on the stack. @@ -827,12 +838,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -843,12 +854,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -859,12 +870,12 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "z" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -873,10 +884,10 @@ Definition mulmod : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -884,7 +895,7 @@ Definition mulmod : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "z" |), + M.get_name (| globals, locals_stack, "z" |), Constant.int 0 |), (* then *) @@ -892,7 +903,7 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -905,14 +916,14 @@ Definition mulmod : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.mod_ (| BinOp.mult (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |), - M.get_name (| globals, "z" |) + M.get_name (| globals, locals_stack, "z" |) |) ], make_dict [] @@ -921,23 +932,24 @@ Definition mulmod : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition exp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Exponential operation of the top 2 elements. Pushes the result back on the stack. @@ -951,12 +963,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "base" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -967,12 +979,12 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -983,7 +995,7 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "exponent_bits" , M.call (| - M.get_field (| M.get_name (| globals, "exponent" |), "bit_length" |), + M.get_field (| M.get_name (| globals, locals_stack, "exponent" |), "bit_length" |), make_list [], make_dict [] |) @@ -992,21 +1004,21 @@ Definition exp : Value.t -> Value.t -> M := "exponent_bytes" , BinOp.floor_div (| BinOp.add (| - M.get_name (| globals, "exponent_bits" |), + M.get_name (| globals, locals_stack, "exponent_bits" |), Constant.int 7 |), Constant.int 8 |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_EXPONENTIATION" |), + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION" |), BinOp.mult (| - M.get_name (| globals, "GAS_EXPONENTIATION_PER_BYTE" |), - M.get_name (| globals, "exponent_bytes" |) + M.get_name (| globals, locals_stack, "GAS_EXPONENTIATION_PER_BYTE" |), + M.get_name (| globals, locals_stack, "exponent_bytes" |) |) |) ], @@ -1015,14 +1027,14 @@ Definition exp : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "pow" |), + M.get_name (| globals, locals_stack, "pow" |), make_list [ - M.get_name (| globals, "base" |); - M.get_name (| globals, "exponent" |); - M.get_name (| globals, "U256_CEIL_VALUE" |) + M.get_name (| globals, locals_stack, "base" |); + M.get_name (| globals, locals_stack, "exponent" |); + M.get_name (| globals, locals_stack, "U256_CEIL_VALUE" |) ], make_dict [] |) @@ -1031,23 +1043,24 @@ Definition exp : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signextend : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Sign extend operation. In other words, extend a signed number which fits in N bytes to 32 bytes. @@ -1061,9 +1074,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_num" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1071,18 +1084,18 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_LOW" |) ], make_dict [] |) in @@ -1090,14 +1103,14 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 31 |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "result" , - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -1105,10 +1118,10 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.call (| - M.get_name (| globals, "bytes" |), + M.get_name (| globals, locals_stack, "bytes" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "value" |), "to_be_bytes32" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "to_be_bytes32" |), make_list [], make_dict [] |) @@ -1119,13 +1132,13 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "value_bytes" , M.slice (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), BinOp.sub (| Constant.int 31, M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ - M.get_name (| globals, "byte_num" |) + M.get_name (| globals, locals_stack, "byte_num" |) ], make_dict [] |) @@ -1138,7 +1151,7 @@ Definition signextend : Value.t -> Value.t -> M := "sign_bit" , BinOp.r_shift (| M.get_subscript (| - M.get_name (| globals, "value_bytes" |), + M.get_name (| globals, locals_stack, "value_bytes" |), Constant.int 0 |), Constant.int 7 @@ -1148,7 +1161,7 @@ Definition signextend : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "sign_bit" |), + M.get_name (| globals, locals_stack, "sign_bit" |), Constant.int 0 |), (* then *) @@ -1156,9 +1169,9 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) ], make_dict [] |) @@ -1171,7 +1184,7 @@ Definition signextend : Value.t -> Value.t -> M := BinOp.sub (| Constant.int 32, BinOp.add (| - M.get_name (| globals, "byte_num" |), + M.get_name (| globals, locals_stack, "byte_num" |), Constant.int 1 |) |) @@ -1179,22 +1192,22 @@ Definition signextend : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ BinOp.add (| M.call (| - M.get_name (| globals, "bytearray" |), + M.get_name (| globals, locals_stack, "bytearray" |), make_list [ BinOp.mult (| make_list [ Constant.int 255 ], - M.get_name (| globals, "num_bytes_prepend" |) + M.get_name (| globals, locals_stack, "num_bytes_prepend" |) |) ], make_dict [] |), - M.get_name (| globals, "value_bytes" |) + M.get_name (| globals, locals_stack, "value_bytes" |) |) ], make_dict [] @@ -1205,16 +1218,16 @@ Definition signextend : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/bitwise.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/bitwise.v index b526d4e..e3d76aa 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/bitwise.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/bitwise.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.bitwise". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.bitwise". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition bitwise_and : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise AND operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,42 +62,43 @@ Definition bitwise_and : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_and (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_or : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise OR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -108,9 +112,9 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -118,42 +122,43 @@ Definition bitwise_or : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_or (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_xor : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise XOR operation of the top 2 elements of the stack. Pushes the result back on the stack. @@ -167,9 +172,9 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -177,42 +182,43 @@ Definition bitwise_xor : Value.t -> Value.t -> M := let _ := M.assign_local (| "y" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); BinOp.bit_xor (| - M.get_name (| globals, "x" |), - M.get_name (| globals, "y" |) + M.get_name (| globals, locals_stack, "x" |), + M.get_name (| globals, locals_stack, "y" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition bitwise_not : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Bitwise NOT operation of the top element of the stack. Pushes the result back on the stack. @@ -226,39 +232,40 @@ Definition bitwise_not : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - UnOp.invert (| M.get_name (| globals, "x" |) |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + UnOp.invert (| M.get_name (| globals, locals_stack, "x" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition get_byte : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " For a word (defined by next top element of the stack), retrieve the Nth byte (0-indexed and defined by top element of stack) from the @@ -273,9 +280,9 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "byte_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -283,18 +290,18 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in @@ -302,7 +309,7 @@ Definition get_byte : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt_e (| - M.get_name (| globals, "byte_index" |), + M.get_name (| globals, locals_stack, "byte_index" |), Constant.int 32 |), (* then *) @@ -310,7 +317,7 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -324,15 +331,15 @@ Definition get_byte : Value.t -> Value.t -> M := "extra_bytes_to_right" , BinOp.sub (| Constant.int 31, - M.get_name (| globals, "byte_index" |) + M.get_name (| globals, locals_stack, "byte_index" |) |) |) in let _ := M.assign_local (| "word" , BinOp.r_shift (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), BinOp.mult (| - M.get_name (| globals, "extra_bytes_to_right" |), + M.get_name (| globals, locals_stack, "extra_bytes_to_right" |), Constant.int 8 |) |) @@ -340,16 +347,16 @@ Definition get_byte : Value.t -> Value.t -> M := let _ := M.assign_local (| "word" , BinOp.bit_and (| - M.get_name (| globals, "word" |), + M.get_name (| globals, locals_stack, "word" |), Constant.int 255 |) |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "word" |) + M.get_name (| globals, locals_stack, "word" |) ], make_dict [] |) @@ -357,16 +364,16 @@ Definition get_byte : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/block.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/block.v index 22c744e..55ba480 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/block.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/block.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.block". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.block". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition block_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the hash of one of the 256 most recent complete blocks onto the stack. The block number to hash is present at the top of the stack. @@ -51,18 +54,18 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "block_number" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BLOCK_HASH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BLOCK_HASH" |) ], make_dict [] |) in @@ -71,14 +74,14 @@ Definition block_hash : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |), ltac:(M.monadic ( Compare.gt (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), BinOp.add (| - M.get_name (| globals, "block_number" |), + M.get_name (| globals, locals_stack, "block_number" |), Constant.int 256 |) |) @@ -96,23 +99,23 @@ Definition block_hash : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.get_subscript (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "block_hashes" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "block_hashes" |), UnOp.sub (| BinOp.sub (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |), - M.get_name (| globals, "block_number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |), + M.get_name (| globals, locals_stack, "block_number" |) |) |) |) |) in M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -121,14 +124,15 @@ Definition block_hash : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition coinbase : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's beneficiary address (address of the block miner) onto the stack. @@ -144,21 +148,21 @@ Definition coinbase : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "coinbase" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "coinbase" |) ], make_dict [] |) @@ -167,14 +171,15 @@ Definition coinbase : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition timestamp : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's timestamp onto the stack. Here the timestamp being referred is actually the unix timestamp in seconds. @@ -190,31 +195,32 @@ Definition timestamp : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "time" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "time" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition number : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's number onto the stack. @@ -229,21 +235,21 @@ Definition number : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "number" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "number" |) ], make_dict [] |) @@ -252,14 +258,15 @@ Definition number : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition difficulty : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's difficulty onto the stack. @@ -274,21 +281,21 @@ Definition difficulty : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "difficulty" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "difficulty" |) ], make_dict [] |) @@ -297,14 +304,15 @@ Definition difficulty : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_limit : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the current block's gas limit onto the stack. @@ -319,21 +327,21 @@ Definition gas_limit : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_limit" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_limit" |) ], make_dict [] |) @@ -342,7 +350,7 @@ Definition gas_limit : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/comparison.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/comparison.v index 7e7ac0d..d7aaec2 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/comparison.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/comparison.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.comparison". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.comparison". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is less than the next top element. Pushes the result back on the stack. @@ -49,9 +52,9 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -59,52 +62,53 @@ Definition less_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_less_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed less-than comparison. @@ -118,9 +122,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -132,9 +136,9 @@ Definition signed_less_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -143,44 +147,45 @@ Definition signed_less_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.lt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is greater than the next top element. Pushes the result back on the stack. @@ -194,9 +199,9 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -204,52 +209,53 @@ Definition greater_than : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition signed_greater_than : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Signed greater-than comparison. @@ -263,9 +269,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "left" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -277,9 +283,9 @@ Definition signed_greater_than : Value.t -> Value.t -> M := "right" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_signed" |), @@ -288,44 +294,45 @@ Definition signed_greater_than : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.gt (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition equal : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to the next top element. Pushes the result back on the stack. @@ -339,9 +346,9 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "left" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -349,52 +356,53 @@ Definition equal : Value.t -> Value.t -> M := let _ := M.assign_local (| "right" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "left" |), - M.get_name (| globals, "right" |) + M.get_name (| globals, locals_stack, "left" |), + M.get_name (| globals, locals_stack, "right" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition is_zero : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if the top element is equal to 0. Pushes the result back on the stack. @@ -408,28 +416,28 @@ Definition is_zero : Value.t -> Value.t -> M := let _ := M.assign_local (| "x" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "result" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Compare.eq (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), Constant.int 0 |) ], @@ -437,16 +445,16 @@ Definition is_zero : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "result" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "result" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/control_flow.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/control_flow.v index 6ba53bf..bb32d47 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/control_flow.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/control_flow.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.control_flow". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.control_flow". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition stop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stop further execution of EVM code. @@ -58,19 +61,20 @@ Definition stop : Value.t -> Value.t -> M := let _ := M.pass (| |) in let _ := M.pass (| |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jump : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the location specified by the top of the stack. @@ -84,12 +88,12 @@ Definition jump : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -98,10 +102,10 @@ Definition jump : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_MID" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_MID" |) ], make_dict [] |) in @@ -109,23 +113,23 @@ Definition jump : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) ], make_dict [] |) @@ -133,8 +137,9 @@ Definition jump : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition jumpi : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Alter the program counter to the specified location if and only if a condition is true. If the condition is not true, then the program counter @@ -149,12 +154,12 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "jump_dest" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -165,18 +170,18 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "conditional_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_HIGH" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_HIGH" |) ], make_dict [] |) in @@ -184,7 +189,7 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "conditional_value" |), + M.get_name (| globals, locals_stack, "conditional_value" |), Constant.int 0 |), (* then *) @@ -192,7 +197,7 @@ Definition jumpi : Value.t -> Value.t -> M := let _ := M.assign_local (| "destination" , BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) |) in @@ -203,29 +208,29 @@ Definition jumpi : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "jump_dest" |), - M.get_field (| M.get_name (| globals, "evm" |), "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "jump_dest" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "valid_jump_destinations" |) |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "InvalidJumpDestError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "InvalidJumpDestError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "destination" , - M.get_name (| globals, "jump_dest" |) + M.get_name (| globals, locals_stack, "jump_dest" |) |) in M.pure Constant.None_ )) |) in M.pure Constant.None_ )) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "destination" |) + M.get_name (| globals, locals_stack, "destination" |) ], make_dict [] |) @@ -233,8 +238,9 @@ Definition jumpi : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition pc : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push onto the stack the value of the program counter after reaching the current instruction and without increasing it for the next instruction. @@ -247,21 +253,21 @@ Definition pc : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "pc" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |) ], make_dict [] |) @@ -270,14 +276,15 @@ Definition pc : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gas_left : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the amount of available gas (including the corresponding reduction for the cost of this instruction) onto the stack. @@ -290,21 +297,21 @@ Definition gas_left : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -313,14 +320,15 @@ Definition gas_left : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition jumpdest : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Mark a valid destination for jumps. This is a noop, present only to be used by `JUMP` and `JUMPI` opcodes to verify that their jump is @@ -334,17 +342,17 @@ Definition jumpdest : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_JUMPDEST" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_JUMPDEST" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/environment.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/environment.v index 6f5e691..75c6d21 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/environment.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/environment.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.environment". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.environment". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -60,8 +62,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition address : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the current executing account to the stack. @@ -73,21 +76,21 @@ Definition address : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -96,14 +99,15 @@ Definition address : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition balance : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the balance of the given account onto the stack. @@ -116,12 +120,12 @@ Definition balance : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -130,42 +134,43 @@ Definition balance : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BALANCE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BALANCE" |) ], make_dict [] |) in let _ := M.assign_local (| "balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "balance" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "balance" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition origin : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the original transaction sender to the stack. The origin address can only be an EOA. @@ -178,21 +183,21 @@ Definition origin : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "origin" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "origin" |) ], make_dict [] |) @@ -201,14 +206,15 @@ Definition origin : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition caller : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes the address of the caller onto the stack. @@ -220,21 +226,21 @@ Definition caller : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |) ], make_dict [] |) @@ -243,14 +249,15 @@ Definition caller : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callvalue : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the value (in wei) sent with the call onto the stack. @@ -262,31 +269,32 @@ Definition callvalue : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldataload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push a word (32 bytes) of the input data belonging to the current environment onto the stack. @@ -300,30 +308,30 @@ Definition calldataload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "start_index" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "start_index" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -334,13 +342,13 @@ Definition calldataload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -349,14 +357,15 @@ Definition calldataload : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatasize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of input data in current environment onto the stack. @@ -368,24 +377,24 @@ Definition calldatasize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) ], make_dict [] |) @@ -397,14 +406,15 @@ Definition calldatasize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition calldatacopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the input data in current environment to memory. @@ -420,9 +430,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -430,9 +440,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "data_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -440,9 +450,9 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -451,12 +461,12 @@ Definition calldatacopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -469,76 +479,77 @@ Definition calldatacopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |); - M.get_name (| globals, "data_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |); + M.get_name (| globals, locals_stack, "data_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of code running in current environment onto the stack. @@ -550,24 +561,24 @@ Definition codesize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |) ], make_dict [] |) @@ -579,14 +590,15 @@ Definition codesize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition codecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of the code in current environment to memory. @@ -602,9 +614,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -612,9 +624,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -622,9 +634,9 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -633,12 +645,12 @@ Definition codecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -651,76 +663,77 @@ Definition codecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition gasprice : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the gas price used in current environment onto the stack. @@ -732,21 +745,21 @@ Definition gasprice : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "gas_price" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "gas_price" |) ], make_dict [] |) @@ -755,14 +768,15 @@ Definition gasprice : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodesize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the code size of a given account onto the stack. @@ -775,12 +789,12 @@ Definition extcodesize : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -789,26 +803,26 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_EXTERNAL" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |) ], make_dict [] |) in let _ := M.assign_local (| "codesize" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -820,23 +834,24 @@ Definition extcodesize : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "codesize" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "codesize" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition extcodecopy : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Copy a portion of an account's code to memory. @@ -849,12 +864,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -865,9 +880,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -875,9 +890,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -885,9 +900,9 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -896,12 +911,12 @@ Definition extcodecopy : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -914,52 +929,52 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "copy_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_COPY" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_COPY" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_EXTERNAL" |), - M.get_name (| globals, "copy_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_EXTERNAL" |), + M.get_name (| globals, locals_stack, "copy_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "address" |) ], make_dict [] |), "code" |) @@ -967,27 +982,27 @@ Definition extcodecopy : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "code" |); - M.get_name (| globals, "code_start_index" |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "code" |); + M.get_name (| globals, locals_stack, "code_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/keccak.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/keccak.v index d8e8086..252a3f2 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/keccak.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/keccak.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.keccak". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.keccak". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -49,8 +51,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition keccak : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes to the stack the Keccak-256 hash of a region of memory. @@ -66,9 +69,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -87,12 +90,12 @@ Definition keccak : Value.t -> Value.t -> M := "words" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -105,53 +108,53 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "word_gas_cost" , BinOp.mult (| - M.get_name (| globals, "GAS_KECCAK256_WORD" |), - M.get_name (| globals, "words" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256_WORD" |), + M.get_name (| globals, locals_stack, "words" |) |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_KECCAK256" |), - M.get_name (| globals, "word_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_KECCAK256" |), + M.get_name (| globals, locals_stack, "word_gas_cost" |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_index" |); - M.get_name (| globals, "size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_index" |); + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -159,21 +162,21 @@ Definition keccak : Value.t -> Value.t -> M := let _ := M.assign_local (| "hash" , M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_name (| globals, "hash" |) + M.get_name (| globals, locals_stack, "hash" |) ], make_dict [] |) @@ -182,7 +185,7 @@ Definition keccak : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/log.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/log.v index 45018dd..aa9820a 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/log.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/log.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.log". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.log". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -47,8 +49,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_pop : IsImported globals "ethereum.tangerine_whistle.vm.stack" "pop". Definition log_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_topics" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_topics" ] in + ltac:(M.monadic ( let _ := Constant.str " Appends a log entry, having `num_topics` topics, to the evm logs. @@ -66,9 +69,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_index" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -76,9 +79,9 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -89,11 +92,11 @@ Definition log_n : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "_" |), + M.get_name (| globals, locals_stack, "_" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "num_topics" |) ], make_dict [] |), @@ -102,9 +105,9 @@ Definition log_n : Value.t -> Value.t -> M := "topic" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -113,9 +116,9 @@ Definition log_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "topics" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "topics" |), "append" |), make_list [ - M.get_name (| globals, "topic" |) + M.get_name (| globals, locals_stack, "topic" |) ], make_dict [] |) in @@ -128,74 +131,74 @@ Definition log_n : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_index" |); M.get_name (| globals, "size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_index" |); M.get_name (| globals, locals_stack, "size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_LOG" |), + M.get_name (| globals, locals_stack, "GAS_LOG" |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_DATA" |), - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "GAS_LOG_DATA" |), + M.get_name (| globals, locals_stack, "size" |) |) |), BinOp.mult (| - M.get_name (| globals, "GAS_LOG_TOPIC" |), - M.get_name (| globals, "num_topics" |) + M.get_name (| globals, locals_stack, "GAS_LOG_TOPIC" |), + M.get_name (| globals, locals_stack, "num_topics" |) |) |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "log_entry" , M.call (| - M.get_name (| globals, "Log" |), + M.get_name (| globals, locals_stack, "Log" |), make_list [], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "logs" |), - make_tuple [ M.get_name (| globals, "log_entry" |) ] + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |), + make_tuple [ M.get_name (| globals, locals_stack, "log_entry" |) ] |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition log0 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -203,9 +206,9 @@ Definition log0 : Value.t := M.run ltac:(M.monadic ( Definition log1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -213,9 +216,9 @@ Definition log1 : Value.t := M.run ltac:(M.monadic ( Definition log2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -223,9 +226,9 @@ Definition log2 : Value.t := M.run ltac:(M.monadic ( Definition log3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) @@ -233,9 +236,9 @@ Definition log3 : Value.t := M.run ltac:(M.monadic ( Definition log4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "log_n" |) + M.get_name (| globals, locals_stack, "log_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/memory.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/memory.v index ca0b278..f7f9ed6 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/memory.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.memory". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition mstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a word to memory. This also expands the memory, if the memory is @@ -61,9 +64,9 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -72,9 +75,9 @@ Definition mstore : Value.t -> Value.t -> M := "value" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -85,17 +88,17 @@ Definition mstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) @@ -108,43 +111,44 @@ Definition mstore : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mstore8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a byte to memory. This also expands the memory, if the memory is @@ -159,9 +163,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -169,9 +173,9 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -179,12 +183,12 @@ Definition mstore8 : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -196,32 +200,32 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "normalized_bytes_value" , M.call (| - M.get_name (| globals, "Bytes" |), + M.get_name (| globals, locals_stack, "Bytes" |), make_list [ make_list [ BinOp.bit_and (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 255 |) ] @@ -230,24 +234,25 @@ Definition mstore8 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); - M.get_name (| globals, "normalized_bytes_value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); + M.get_name (| globals, locals_stack, "normalized_bytes_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition mload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Load word from memory. @@ -260,9 +265,9 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -270,12 +275,12 @@ Definition mload : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + make_tuple [ M.get_name (| globals, locals_stack, "start_position" |); M.call (| + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -287,36 +292,36 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_VERY_LOW" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "value" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "start_position" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -330,23 +335,24 @@ Definition mload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition msize : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Push the size of active memory in bytes onto the stack. @@ -358,24 +364,24 @@ Definition msize : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |) ], make_dict [] |) @@ -387,7 +393,7 @@ Definition msize : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/stack.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/stack.v index 91f636b..6dcf61d 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/stack.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.stack". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_tangerine_whistle_vm_memory_imports_buffer_read : IsImported globals "ethereum.tangerine_whistle.vm.memory" "buffer_read". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove item from stack. @@ -57,31 +60,32 @@ Definition pop : Value.t -> Value.t -> M := " in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_BASE" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_BASE" |) ], make_dict [] |) in let _ := M.pass (| |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "num_bytes" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "num_bytes" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes a N-byte immediate onto the stack. @@ -97,36 +101,36 @@ Definition push_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_push" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "code" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "code" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ BinOp.add (| - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) ], make_dict [] |) @@ -138,26 +142,27 @@ Definition push_n : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_push" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_push" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), BinOp.add (| Constant.int 1, - M.get_name (| globals, "num_bytes" |) + M.get_name (| globals, locals_stack, "num_bytes" |) |) |) in M.pure Constant.None_)). Definition dup_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Duplicate the Nth stack item (from top of the stack) to the top of stack. @@ -173,67 +178,68 @@ Definition dup_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign_local (| "data_to_duplicate" , M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| BinOp.sub (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) |) in let _ := M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "push" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "data_to_duplicate" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "data_to_duplicate" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition swap_n : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "item_number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "item_number" ] in + ltac:(M.monadic ( let _ := Constant.str " Swap the top and the `item_number` element of the stack, where the top of the stack is position zero. @@ -253,64 +259,64 @@ Definition swap_n : Value.t -> Value.t -> M := " in let _ := M.pass (| |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_VERY_LOW" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_VERY_LOW" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "ensure" |), + M.get_name (| globals, locals_stack, "ensure" |), make_list [ Compare.lt (| - M.get_name (| globals, "item_number" |), + M.get_name (| globals, locals_stack, "item_number" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |); - M.get_name (| globals, "StackUnderflowError" |) + M.get_name (| globals, locals_stack, "StackUnderflowError" |) ], make_dict [] |) in let _ := M.assign (| make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |) ], make_tuple [ M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), BinOp.sub (| UnOp.sub (| Constant.int 1 |), - M.get_name (| globals, "item_number" |) + M.get_name (| globals, locals_stack, "item_number" |) |) |); M.get_subscript (| - M.get_field (| M.get_name (| globals, "evm" |), "stack" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |), UnOp.sub (| Constant.int 1 |) |) ] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition push1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -318,9 +324,9 @@ Definition push1 : Value.t := M.run ltac:(M.monadic ( Definition push2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -328,9 +334,9 @@ Definition push2 : Value.t := M.run ltac:(M.monadic ( Definition push3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -338,9 +344,9 @@ Definition push3 : Value.t := M.run ltac:(M.monadic ( Definition push4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -348,9 +354,9 @@ Definition push4 : Value.t := M.run ltac:(M.monadic ( Definition push5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -358,9 +364,9 @@ Definition push5 : Value.t := M.run ltac:(M.monadic ( Definition push6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -368,9 +374,9 @@ Definition push6 : Value.t := M.run ltac:(M.monadic ( Definition push7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -378,9 +384,9 @@ Definition push7 : Value.t := M.run ltac:(M.monadic ( Definition push8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -388,9 +394,9 @@ Definition push8 : Value.t := M.run ltac:(M.monadic ( Definition push9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -398,9 +404,9 @@ Definition push9 : Value.t := M.run ltac:(M.monadic ( Definition push10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -408,9 +414,9 @@ Definition push10 : Value.t := M.run ltac:(M.monadic ( Definition push11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -418,9 +424,9 @@ Definition push11 : Value.t := M.run ltac:(M.monadic ( Definition push12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -428,9 +434,9 @@ Definition push12 : Value.t := M.run ltac:(M.monadic ( Definition push13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -438,9 +444,9 @@ Definition push13 : Value.t := M.run ltac:(M.monadic ( Definition push14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -448,9 +454,9 @@ Definition push14 : Value.t := M.run ltac:(M.monadic ( Definition push15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -458,9 +464,9 @@ Definition push15 : Value.t := M.run ltac:(M.monadic ( Definition push16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -468,9 +474,9 @@ Definition push16 : Value.t := M.run ltac:(M.monadic ( Definition push17 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -478,9 +484,9 @@ Definition push17 : Value.t := M.run ltac:(M.monadic ( Definition push18 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -488,9 +494,9 @@ Definition push18 : Value.t := M.run ltac:(M.monadic ( Definition push19 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -498,9 +504,9 @@ Definition push19 : Value.t := M.run ltac:(M.monadic ( Definition push20 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -508,9 +514,9 @@ Definition push20 : Value.t := M.run ltac:(M.monadic ( Definition push21 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -518,9 +524,9 @@ Definition push21 : Value.t := M.run ltac:(M.monadic ( Definition push22 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -528,9 +534,9 @@ Definition push22 : Value.t := M.run ltac:(M.monadic ( Definition push23 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -538,9 +544,9 @@ Definition push23 : Value.t := M.run ltac:(M.monadic ( Definition push24 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -548,9 +554,9 @@ Definition push24 : Value.t := M.run ltac:(M.monadic ( Definition push25 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -558,9 +564,9 @@ Definition push25 : Value.t := M.run ltac:(M.monadic ( Definition push26 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -568,9 +574,9 @@ Definition push26 : Value.t := M.run ltac:(M.monadic ( Definition push27 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -578,9 +584,9 @@ Definition push27 : Value.t := M.run ltac:(M.monadic ( Definition push28 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -588,9 +594,9 @@ Definition push28 : Value.t := M.run ltac:(M.monadic ( Definition push29 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -598,9 +604,9 @@ Definition push29 : Value.t := M.run ltac:(M.monadic ( Definition push30 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -608,9 +614,9 @@ Definition push30 : Value.t := M.run ltac:(M.monadic ( Definition push31 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -618,9 +624,9 @@ Definition push31 : Value.t := M.run ltac:(M.monadic ( Definition push32 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "push_n" |) + M.get_name (| globals, locals_stack, "push_n" |) ], make_dict [] |) @@ -628,9 +634,9 @@ Definition push32 : Value.t := M.run ltac:(M.monadic ( Definition dup1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -638,9 +644,9 @@ Definition dup1 : Value.t := M.run ltac:(M.monadic ( Definition dup2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -648,9 +654,9 @@ Definition dup2 : Value.t := M.run ltac:(M.monadic ( Definition dup3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -658,9 +664,9 @@ Definition dup3 : Value.t := M.run ltac:(M.monadic ( Definition dup4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -668,9 +674,9 @@ Definition dup4 : Value.t := M.run ltac:(M.monadic ( Definition dup5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -678,9 +684,9 @@ Definition dup5 : Value.t := M.run ltac:(M.monadic ( Definition dup6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -688,9 +694,9 @@ Definition dup6 : Value.t := M.run ltac:(M.monadic ( Definition dup7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -698,9 +704,9 @@ Definition dup7 : Value.t := M.run ltac:(M.monadic ( Definition dup8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -708,9 +714,9 @@ Definition dup8 : Value.t := M.run ltac:(M.monadic ( Definition dup9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -718,9 +724,9 @@ Definition dup9 : Value.t := M.run ltac:(M.monadic ( Definition dup10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -728,9 +734,9 @@ Definition dup10 : Value.t := M.run ltac:(M.monadic ( Definition dup11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -738,9 +744,9 @@ Definition dup11 : Value.t := M.run ltac:(M.monadic ( Definition dup12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -748,9 +754,9 @@ Definition dup12 : Value.t := M.run ltac:(M.monadic ( Definition dup13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -758,9 +764,9 @@ Definition dup13 : Value.t := M.run ltac:(M.monadic ( Definition dup14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -768,9 +774,9 @@ Definition dup14 : Value.t := M.run ltac:(M.monadic ( Definition dup15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -778,9 +784,9 @@ Definition dup15 : Value.t := M.run ltac:(M.monadic ( Definition dup16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "dup_n" |) + M.get_name (| globals, locals_stack, "dup_n" |) ], make_dict [] |) @@ -788,9 +794,9 @@ Definition dup16 : Value.t := M.run ltac:(M.monadic ( Definition swap1 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -798,9 +804,9 @@ Definition swap1 : Value.t := M.run ltac:(M.monadic ( Definition swap2 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -808,9 +814,9 @@ Definition swap2 : Value.t := M.run ltac:(M.monadic ( Definition swap3 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -818,9 +824,9 @@ Definition swap3 : Value.t := M.run ltac:(M.monadic ( Definition swap4 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -828,9 +834,9 @@ Definition swap4 : Value.t := M.run ltac:(M.monadic ( Definition swap5 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -838,9 +844,9 @@ Definition swap5 : Value.t := M.run ltac:(M.monadic ( Definition swap6 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -848,9 +854,9 @@ Definition swap6 : Value.t := M.run ltac:(M.monadic ( Definition swap7 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -858,9 +864,9 @@ Definition swap7 : Value.t := M.run ltac:(M.monadic ( Definition swap8 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -868,9 +874,9 @@ Definition swap8 : Value.t := M.run ltac:(M.monadic ( Definition swap9 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -878,9 +884,9 @@ Definition swap9 : Value.t := M.run ltac:(M.monadic ( Definition swap10 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -888,9 +894,9 @@ Definition swap10 : Value.t := M.run ltac:(M.monadic ( Definition swap11 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -898,9 +904,9 @@ Definition swap11 : Value.t := M.run ltac:(M.monadic ( Definition swap12 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -908,9 +914,9 @@ Definition swap12 : Value.t := M.run ltac:(M.monadic ( Definition swap13 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -918,9 +924,9 @@ Definition swap13 : Value.t := M.run ltac:(M.monadic ( Definition swap14 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -928,9 +934,9 @@ Definition swap14 : Value.t := M.run ltac:(M.monadic ( Definition swap15 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) @@ -938,9 +944,9 @@ Definition swap15 : Value.t := M.run ltac:(M.monadic ( Definition swap16 : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "partial" |), + M.get_name (| globals, locals_stack, "partial" |), make_list [ - M.get_name (| globals, "swap_n" |) + M.get_name (| globals, locals_stack, "swap_n" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/storage.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/storage.v index d1261c9..3679ce4 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/storage.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/storage.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.storage". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.storage". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -42,8 +44,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition sload : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Loads to the stack, the value corresponding to a certain key from the storage of the current account. @@ -58,9 +61,9 @@ Definition sload : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -69,43 +72,44 @@ Definition sload : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_SLOAD" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_SLOAD" |) ], make_dict [] |) in let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); - M.get_name (| globals, "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition sstore : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Stores a value at a certain key in the current context's storage. @@ -119,9 +123,9 @@ Definition sstore : Value.t -> Value.t -> M := "key" , M.call (| M.get_field (| M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |), "to_be_bytes32" |), @@ -132,9 +136,9 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "new_value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -142,11 +146,11 @@ Definition sstore : Value.t -> Value.t -> M := let _ := M.assign_local (| "current_value" , M.call (| - M.get_name (| globals, "get_storage" |), + M.get_name (| globals, locals_stack, "get_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |) ], make_dict [] |) @@ -156,12 +160,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -170,14 +174,14 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_SET" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_SET" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_STORAGE_UPDATE" |) + M.get_name (| globals, locals_stack, "GAS_STORAGE_UPDATE" |) |) in M.pure Constant.None_ )) |) in @@ -186,12 +190,12 @@ Definition sstore : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.eq (| - M.get_name (| globals, "new_value" |), + M.get_name (| globals, locals_stack, "new_value" |), Constant.int 0 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "current_value" |), + M.get_name (| globals, locals_stack, "current_value" |), Constant.int 0 |) )) @@ -200,8 +204,8 @@ Definition sstore : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "GAS_STORAGE_CLEAR_REFUND" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "GAS_STORAGE_CLEAR_REFUND" |) |) in M.pure Constant.None_ (* else *) @@ -209,26 +213,26 @@ Definition sstore : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_storage" |), + M.get_name (| globals, locals_stack, "set_storage" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "key" |); - M.get_name (| globals, "new_value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "key" |); + M.get_name (| globals, locals_stack, "new_value" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/system.v b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/system.v index a103f8e..541db61 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/system.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/instructions/system.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.instructions.system". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.instructions.system". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -88,8 +90,9 @@ Axiom ethereum_tangerine_whistle_vm_stack_imports_push : IsImported globals "ethereum.tangerine_whistle.vm.stack" "push". Definition create : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Creates a new account with associated code. @@ -102,9 +105,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "endowment" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -112,9 +115,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -122,9 +125,9 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -132,23 +135,23 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_CREATE" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_CREATE" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] @@ -156,12 +159,12 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "create_message_gas" , M.call (| - M.get_name (| globals, "max_message_call_gas" |), + M.get_name (| globals, locals_stack, "max_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |) @@ -171,28 +174,28 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.sub, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_address" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "sender" , M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "sender_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "sender_address" |) ], make_dict [] |) @@ -200,14 +203,14 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "contract_address" , M.call (| - M.get_name (| globals, "compute_contract_address" |), + M.get_name (| globals, locals_stack, "compute_contract_address" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "nonce" |) @@ -220,15 +223,15 @@ Definition create : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.or (| Compare.lt (| - M.get_field (| M.get_name (| globals, "sender" |), "balance" |), - M.get_name (| globals, "endowment" |) + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "balance" |), + M.get_name (| globals, locals_stack, "endowment" |) |), ltac:(M.monadic ( BoolOp.or (| Compare.eq (| - M.get_field (| M.get_name (| globals, "sender" |), "nonce" |), + M.get_field (| M.get_name (| globals, locals_stack, "sender" |), "nonce" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ BinOp.sub (| BinOp.pow (| @@ -244,10 +247,10 @@ Definition create : Value.t -> Value.t -> M := ltac:(M.monadic ( Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |) )) |) @@ -256,11 +259,11 @@ Definition create : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -271,8 +274,8 @@ Definition create : Value.t -> Value.t -> M := |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "create_message_gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "create_message_gas" |) |) in M.pure Constant.None_ (* else *) @@ -281,29 +284,29 @@ Definition create : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "contract_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "contract_address" |) ], make_dict [] |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -318,27 +321,27 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "increment_nonce" |), + M.get_name (| globals, locals_stack, "increment_nonce" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -346,10 +349,10 @@ Definition create : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -357,23 +360,23 @@ Definition create : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -386,21 +389,21 @@ Definition create : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "child_evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "message" |), "current_target" |) ], make_dict [] |) @@ -415,14 +418,15 @@ Definition create : Value.t -> Value.t -> M := )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition return_ : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halts execution returning output data. @@ -434,9 +438,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -444,9 +448,9 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -454,57 +458,58 @@ Definition return_ : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_start_position" |); M.get_name (| globals, "memory_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_start_position" |); M.get_name (| globals, locals_stack, "memory_size" |) ] ] ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_ZERO" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_name (| globals, locals_stack, "GAS_ZERO" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_start_position" |); - M.get_name (| globals, "memory_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_start_position" |); + M.get_name (| globals, locals_stack, "memory_size" |) ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition generic_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "gas"; "value"; "caller"; "to"; "code_address"; "should_transfer_value"; "memory_input_start_position"; "memory_input_size"; "memory_output_start_position"; "memory_output_size" ] in + ltac:(M.monadic ( let _ := Constant.str " Perform the core logic of the `CALL*` family of opcodes. " in @@ -514,24 +519,24 @@ Definition generic_call : Value.t -> Value.t -> M := M.if_then_else (| Compare.gt (| BinOp.add (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "depth" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "depth" |), Constant.int 1 |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_name (| globals, "gas" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_name (| globals, locals_stack, "gas" |) |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -551,11 +556,11 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "call_data" , M.call (| - M.get_name (| globals, "memory_read_bytes" |), + M.get_name (| globals, locals_stack, "memory_read_bytes" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |) ], make_dict [] |) @@ -563,10 +568,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "code" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "code_address" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "code_address" |) ], make_dict [] |), "code" |) @@ -574,7 +579,7 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_message" , M.call (| - M.get_name (| globals, "Message" |), + M.get_name (| globals, locals_stack, "Message" |), make_list [], make_dict [] |) @@ -582,10 +587,10 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "child_evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "child_message" |); - M.get_field (| M.get_name (| globals, "evm" |), "env" |) + M.get_name (| globals, locals_stack, "child_message" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |) ], make_dict [] |) @@ -593,23 +598,23 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "child_evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_error" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_error" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -622,19 +627,19 @@ Definition generic_call : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "incorporate_child_on_success" |), + M.get_name (| globals, locals_stack, "incorporate_child_on_success" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "child_evm" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "child_evm" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1 ], @@ -648,16 +653,16 @@ Definition generic_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "actual_output_size" , M.call (| - M.get_name (| globals, "min" |), + M.get_name (| globals, locals_stack, "min" |), make_list [ - M.get_name (| globals, "memory_output_size" |); + M.get_name (| globals, locals_stack, "memory_output_size" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |) ], make_dict [] |) @@ -669,14 +674,14 @@ Definition generic_call : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "memory_write" |), + M.get_name (| globals, locals_stack, "memory_write" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); - M.get_name (| globals, "memory_output_start_position" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.slice (| - M.get_field (| M.get_name (| globals, "child_evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "child_evm" |), "output" |), Constant.None_, - M.get_name (| globals, "actual_output_size" |), + M.get_name (| globals, locals_stack, "actual_output_size" |), Constant.None_ |) ], @@ -685,8 +690,9 @@ Definition generic_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -698,12 +704,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -714,12 +720,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "to" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -730,9 +736,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -740,9 +746,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -750,9 +756,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -760,9 +766,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -770,9 +776,9 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -780,12 +786,12 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -794,10 +800,10 @@ Definition call : Value.t -> Value.t -> M := let _ := M.assign_local (| "_account_exists" , M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "to" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "to" |) ], make_dict [] |) @@ -806,11 +812,11 @@ Definition call : Value.t -> Value.t -> M := "create_gas_cost" , (* if *) M.if_then_else (| - M.get_name (| globals, "_account_exists" |), + M.get_name (| globals, locals_stack, "_account_exists" |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -818,7 +824,7 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_NEW_ACCOUNT" |) +M.get_name (| globals, locals_stack, "GAS_NEW_ACCOUNT" |) )) |) |) in let _ := M.assign_local (| @@ -826,13 +832,13 @@ M.get_name (| globals, "GAS_NEW_ACCOUNT" |) (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -840,61 +846,61 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "create_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "create_gas_cost" |) |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -903,17 +909,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -924,26 +930,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "to" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "to" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -951,14 +957,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition callcode : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into this account with alternative account’s code. @@ -970,12 +977,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -986,12 +993,12 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1002,9 +1009,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "value" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1012,9 +1019,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1022,9 +1029,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1032,9 +1039,9 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1042,26 +1049,26 @@ Definition callcode : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) |) in let _ := M.assign_local (| "to" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1072,13 +1079,13 @@ Definition callcode : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) ltac:(M.monadic ( M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -1086,58 +1093,58 @@ M.call (| |) (* else *) )), ltac:(M.monadic ( -M.get_name (| globals, "GAS_CALL_VALUE" |) +M.get_name (| globals, locals_stack, "GAS_CALL_VALUE" |) )) |) |) in let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ - M.get_name (| globals, "value" |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); BinOp.add (| - M.get_name (| globals, "GAS_CALL" |), - M.get_name (| globals, "transfer_gas_cost" |) + M.get_name (| globals, locals_stack, "GAS_CALL" |), + M.get_name (| globals, locals_stack, "transfer_gas_cost" |) |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.assign_local (| "sender_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) ], make_dict [] |), "balance" |) @@ -1146,17 +1153,17 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "sender_balance" |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "sender_balance" |), + M.get_name (| globals, locals_stack, "value" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "push" |), + M.get_name (| globals, locals_stack, "push" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1167,26 +1174,26 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |), - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |), + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_name (| globals, "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "to" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_name (| globals, locals_stack, "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "to" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool true; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in @@ -1194,14 +1201,15 @@ M.get_name (| globals, "GAS_CALL_VALUE" |) )) |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). Definition selfdestruct : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Halt execution and register account for later deletion. @@ -1213,12 +1221,12 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "beneficiary" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1228,16 +1236,16 @@ Definition selfdestruct : Value.t -> Value.t -> M := |) in let _ := M.assign_local (| "gas_cost" , - M.get_name (| globals, "GAS_SELF_DESTRUCT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT" |) |) in let _ := (* if *) M.if_then_else (| UnOp.not (| M.call (| - M.get_name (| globals, "account_exists" |), + M.get_name (| globals, locals_stack, "account_exists" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |) |), @@ -1246,7 +1254,7 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "gas_cost", - M.get_name (| globals, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) + M.get_name (| globals, locals_stack, "GAS_SELF_DESTRUCT_NEW_ACCOUNT" |) |) in M.pure Constant.None_ (* else *) @@ -1255,33 +1263,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := )) |) in let _ := M.assign_local (| "originator" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |) |) in let _ := M.assign_local (| "refunded_accounts" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "parent_evm" |) |) in let _ := M.while (| Compare.is_not (| - M.get_name (| globals, "parent_evm" |), + M.get_name (| globals, locals_stack, "parent_evm" |), Constant.None_ |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "refunded_accounts" |), "update" |), + M.get_field (| M.get_name (| globals, locals_stack, "refunded_accounts" |), "update" |), make_list [ - M.get_field (| M.get_name (| globals, "parent_evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "accounts_to_delete" |) ], make_dict [] |) in let _ := M.assign_local (| "parent_evm" , - M.get_field (| M.get_field (| M.get_name (| globals, "parent_evm" |), "message" |), "parent_evm" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "parent_evm" |), "message" |), "parent_evm" |) |) in M.pure Constant.None_ )), @@ -1293,15 +1301,15 @@ Definition selfdestruct : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.not_in (| - M.get_name (| globals, "originator" |), - M.get_name (| globals, "refunded_accounts" |) + M.get_name (| globals, locals_stack, "originator" |), + M.get_name (| globals, locals_stack, "refunded_accounts" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |), - M.get_name (| globals, "REFUND_SELF_DESTRUCT" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |), + M.get_name (| globals, locals_stack, "REFUND_SELF_DESTRUCT" |) |) in M.pure Constant.None_ (* else *) @@ -1309,20 +1317,20 @@ Definition selfdestruct : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "gas_cost" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "gas_cost" |) ], make_dict [] |) in let _ := M.assign_local (| "beneficiary_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |) ], make_dict [] |), "balance" |) @@ -1330,33 +1338,33 @@ Definition selfdestruct : Value.t -> Value.t -> M := let _ := M.assign_local (| "originator_balance" , M.get_field (| M.call (| - M.get_name (| globals, "get_account" |), + M.get_name (| globals, locals_stack, "get_account" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |), "balance" |) |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "beneficiary" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "beneficiary" |); BinOp.add (| - M.get_name (| globals, "beneficiary_balance" |), - M.get_name (| globals, "originator_balance" |) + M.get_name (| globals, locals_stack, "beneficiary_balance" |), + M.get_name (| globals, locals_stack, "originator_balance" |) |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "set_account_balance" |), + M.get_name (| globals, locals_stack, "set_account_balance" |), make_list [ - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "env" |), "state" |); - M.get_name (| globals, "originator" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "env" |), "state" |); + M.get_name (| globals, locals_stack, "originator" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -1366,22 +1374,23 @@ Definition selfdestruct : Value.t -> Value.t -> M := make_dict [] |) in let _ := M.call (| - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |), "add" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |), "add" |), make_list [ - M.get_name (| globals, "originator" |) + M.get_name (| globals, locals_stack, "originator" |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "running" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "running" |), Constant.bool false |) in let _ := M.pass (| |) in M.pure Constant.None_)). Definition delegatecall : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Message-call into an account. @@ -1393,12 +1402,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "gas" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1409,12 +1418,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "code_address" , M.call (| - M.get_name (| globals, "to_address" |), + M.get_name (| globals, locals_stack, "to_address" |), make_list [ M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1425,9 +1434,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1435,9 +1444,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_input_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1445,9 +1454,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_start_position" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1455,9 +1464,9 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "memory_output_size" , M.call (| - M.get_name (| globals, "pop" |), + M.get_name (| globals, locals_stack, "pop" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "stack" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "stack" |) ], make_dict [] |) @@ -1465,12 +1474,12 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "extend_memory" , M.call (| - M.get_name (| globals, "calculate_gas_extend_memory" |), + M.get_name (| globals, locals_stack, "calculate_gas_extend_memory" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "memory" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |); make_list [ - make_tuple [ M.get_name (| globals, "memory_input_start_position" |); M.get_name (| globals, "memory_input_size" |) ]; - make_tuple [ M.get_name (| globals, "memory_output_start_position" |); M.get_name (| globals, "memory_output_size" |) ] + make_tuple [ M.get_name (| globals, locals_stack, "memory_input_start_position" |); M.get_name (| globals, locals_stack, "memory_input_size" |) ]; + make_tuple [ M.get_name (| globals, locals_stack, "memory_output_start_position" |); M.get_name (| globals, locals_stack, "memory_output_size" |) ] ] ], make_dict [] @@ -1479,68 +1488,68 @@ Definition delegatecall : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_call_gas" , M.call (| - M.get_name (| globals, "calculate_message_call_gas" |), + M.get_name (| globals, locals_stack, "calculate_message_call_gas" |), make_list [ M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); - M.get_name (| globals, "gas" |); + M.get_name (| globals, locals_stack, "gas" |); M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) ], make_dict [] |); - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |); - M.get_name (| globals, "GAS_CALL" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |); + M.get_name (| globals, locals_stack, "GAS_CALL" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_field (| M.get_name (| globals, "message_call_gas" |), "cost" |), - M.get_field (| M.get_name (| globals, "extend_memory" |), "cost" |) + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "cost" |), + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "cost" |) |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "memory" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "memory" |), BinOp.mult (| Constant.bytes "00", - M.get_field (| M.get_name (| globals, "extend_memory" |), "expand_by" |) + M.get_field (| M.get_name (| globals, locals_stack, "extend_memory" |), "expand_by" |) |) |) in let _ := M.call (| - M.get_name (| globals, "generic_call" |), + M.get_name (| globals, locals_stack, "generic_call" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_field (| M.get_name (| globals, "message_call_gas" |), "stipend" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "value" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "caller" |); - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "current_target" |); - M.get_name (| globals, "code_address" |); + M.get_name (| globals, locals_stack, "evm" |); + M.get_field (| M.get_name (| globals, locals_stack, "message_call_gas" |), "stipend" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "value" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "caller" |); + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "current_target" |); + M.get_name (| globals, locals_stack, "code_address" |); Constant.bool false; - M.get_name (| globals, "memory_input_start_position" |); - M.get_name (| globals, "memory_input_size" |); - M.get_name (| globals, "memory_output_start_position" |); - M.get_name (| globals, "memory_output_size" |) + M.get_name (| globals, locals_stack, "memory_input_start_position" |); + M.get_name (| globals, locals_stack, "memory_input_size" |); + M.get_name (| globals, locals_stack, "memory_output_start_position" |); + M.get_name (| globals, locals_stack, "memory_output_size" |) ], make_dict [] |) in let _ := M.assign_op (| BinOp.add, - M.get_field (| M.get_name (| globals, "evm" |), "pc" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "pc" |), Constant.int 1 |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/interpreter.v b/CoqOfPython/ethereum/tangerine_whistle/vm/interpreter.v index df0b3aa..2179c16 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/interpreter.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/interpreter.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.interpreter". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.interpreter". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -109,7 +111,7 @@ Axiom ethereum_tangerine_whistle_vm_runtime_imports_get_valid_jump_destinations Definition STACK_DEPTH_LIMIT : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 1024 ], @@ -128,8 +130,9 @@ Definition MessageCallOutput : Value.t := ]. Definition process_message_call : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " If `message.current` is empty then it creates a smart contract else it executes a call from the `message.caller` to the `message.target`. @@ -151,9 +154,9 @@ Definition process_message_call : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_field (| M.get_name (| globals, "message" |), "target" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "target" |), M.call (| - M.get_name (| globals, "Bytes0" |), + M.get_name (| globals, locals_stack, "Bytes0" |), make_list [ Constant.bytes "" ], @@ -165,10 +168,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "is_collision" , M.call (| - M.get_name (| globals, "account_has_code_or_nonce" |), + M.get_name (| globals, locals_stack, "account_has_code_or_nonce" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) @@ -176,39 +179,39 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "is_collision" |), + M.get_name (| globals, locals_stack, "is_collision" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |); M.call (| - M.get_name (| globals, "AddressCollision" |), + M.get_name (| globals, locals_stack, "AddressCollision" |), make_list [], make_dict [] |) @@ -222,10 +225,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_create_message" |), + M.get_name (| globals, locals_stack, "process_create_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -238,10 +241,10 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -251,14 +254,14 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( (* At stmt: unsupported node type: AnnAssign *) let _ := M.assign_local (| "accounts_to_delete" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -266,7 +269,7 @@ Definition process_message_call : Value.t -> Value.t -> M := let _ := M.assign_local (| "refund_counter" , M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], @@ -278,44 +281,44 @@ Definition process_message_call : Value.t -> Value.t -> M := )), ltac:(M.monadic ( let _ := M.assign_local (| "logs" , - M.get_field (| M.get_name (| globals, "evm" |), "logs" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "logs" |) |) in let _ := M.assign_local (| "accounts_to_delete" , - M.get_field (| M.get_name (| globals, "evm" |), "accounts_to_delete" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "accounts_to_delete" |) |) in let _ := M.assign_local (| "refund_counter" , - M.get_field (| M.get_name (| globals, "evm" |), "refund_counter" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "refund_counter" |) |) in M.pure Constant.None_ )) |) in let _ := M.assign_local (| "tx_end" , M.call (| - M.get_name (| globals, "TransactionEnd" |), + M.get_name (| globals, locals_stack, "TransactionEnd" |), make_list [ BinOp.sub (| - M.get_field (| M.get_name (| globals, "message" |), "gas" |), - M.get_field (| M.get_name (| globals, "evm" |), "gas_left" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "gas" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "gas_left" |) |); - M.get_field (| M.get_name (| globals, "evm" |), "output" |); - M.get_field (| M.get_name (| globals, "evm" |), "error" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |); + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) ], make_dict [] |) |) in let _ := M.call (| - M.get_name (| globals, "evm_trace" |), + M.get_name (| globals, locals_stack, "evm_trace" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "tx_end" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "tx_end" |) ], make_dict [] |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "MessageCallOutput" |), + M.get_name (| globals, locals_stack, "MessageCallOutput" |), make_list [], make_dict [] |) @@ -323,8 +326,9 @@ Definition process_message_call : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition process_create_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -341,27 +345,27 @@ Definition process_create_message : Value.t -> Value.t -> M := Items containing execution specific objects. " in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "destroy_storage" |), + M.get_name (| globals, locals_stack, "destroy_storage" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "process_message" |), + M.get_name (| globals, locals_stack, "process_message" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -369,24 +373,24 @@ Definition process_create_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - UnOp.not (| M.get_field (| M.get_name (| globals, "evm" |), "error" |) |), + UnOp.not (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |) |), (* then *) ltac:(M.monadic ( let _ := M.assign_local (| "contract_code" , - M.get_field (| M.get_name (| globals, "evm" |), "output" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |) |) in let _ := M.assign_local (| "contract_code_gas" , BinOp.mult (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "contract_code" |) + M.get_name (| globals, locals_stack, "contract_code" |) ], make_dict [] |), - M.get_name (| globals, "GAS_CODE_DEPOSIT" |) + M.get_name (| globals, locals_stack, "GAS_CODE_DEPOSIT" |) |) |) in (* At stmt: unsupported node type: Try *) @@ -394,22 +398,23 @@ Definition process_create_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition process_message : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes a call to create a smart contract. @@ -429,13 +434,13 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.gt (| - M.get_field (| M.get_name (| globals, "message" |), "depth" |), - M.get_name (| globals, "STACK_DEPTH_LIMIT" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "depth" |), + M.get_name (| globals, locals_stack, "STACK_DEPTH_LIMIT" |) |), (* then *) ltac:(M.monadic ( let _ := M.raise (| Some (M.call (| - M.get_name (| globals, "StackDepthLimitError" |), + M.get_name (| globals, locals_stack, "StackDepthLimitError" |), make_list [ Constant.str "Stack depth limit reached" ], @@ -447,17 +452,17 @@ Definition process_message : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.call (| - M.get_name (| globals, "begin_transaction" |), + M.get_name (| globals, locals_stack, "begin_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in let _ := M.call (| - M.get_name (| globals, "touch_account" |), + M.get_name (| globals, locals_stack, "touch_account" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |) ], make_dict [] |) in @@ -465,10 +470,10 @@ Definition process_message : Value.t -> Value.t -> M := (* if *) M.if_then_else (| BoolOp.and (| - M.get_field (| M.get_name (| globals, "message" |), "should_transfer_value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "should_transfer_value" |), ltac:(M.monadic ( Compare.not_eq (| - M.get_field (| M.get_name (| globals, "message" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |), Constant.int 0 |) )) @@ -476,12 +481,12 @@ Definition process_message : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "move_ether" |), + M.get_name (| globals, locals_stack, "move_ether" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |); - M.get_field (| M.get_name (| globals, "message" |), "caller" |); - M.get_field (| M.get_name (| globals, "message" |), "current_target" |); - M.get_field (| M.get_name (| globals, "message" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "caller" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "current_target" |); + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "value" |) ], make_dict [] |) in @@ -493,10 +498,10 @@ Definition process_message : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "execute_code" |), + M.get_name (| globals, locals_stack, "execute_code" |), make_list [ - M.get_name (| globals, "message" |); - M.get_name (| globals, "env" |) + M.get_name (| globals, locals_stack, "message" |); + M.get_name (| globals, locals_stack, "env" |) ], make_dict [] |) @@ -504,13 +509,13 @@ Definition process_message : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_field (| M.get_name (| globals, "evm" |), "error" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "error" |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "rollback_transaction" |), + M.get_name (| globals, locals_stack, "rollback_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in @@ -518,22 +523,23 @@ Definition process_message : Value.t -> Value.t -> M := (* else *) )), ltac:(M.monadic ( let _ := M.call (| - M.get_name (| globals, "commit_transaction" |), + M.get_name (| globals, locals_stack, "commit_transaction" |), make_list [ - M.get_field (| M.get_name (| globals, "env" |), "state" |) + M.get_field (| M.get_name (| globals, locals_stack, "env" |), "state" |) ], make_dict [] |) in M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). Definition execute_code : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "message"; "env" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "message"; "env" ] in + ltac:(M.monadic ( let _ := Constant.str " Executes bytecode present in the `message`. @@ -551,14 +557,14 @@ Definition execute_code : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "code" , - M.get_field (| M.get_name (| globals, "message" |), "code" |) + M.get_field (| M.get_name (| globals, locals_stack, "message" |), "code" |) |) in let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "get_valid_jump_destinations" |), + M.get_name (| globals, locals_stack, "get_valid_jump_destinations" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -566,13 +572,13 @@ Definition execute_code : Value.t -> Value.t -> M := let _ := M.assign_local (| "evm" , M.call (| - M.get_name (| globals, "Evm" |), + M.get_name (| globals, locals_stack, "Evm" |), make_list [], make_dict [] |) |) in (* At stmt: unsupported node type: Try *) let _ := M.return_ (| - M.get_name (| globals, "evm" |) + M.get_name (| globals, locals_stack, "evm" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/memory.v b/CoqOfPython/ethereum/tangerine_whistle/vm/memory.v index e8d40e2..d93ced6 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/memory.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/memory.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.memory". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.memory". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition memory_write : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes to memory. @@ -44,33 +47,34 @@ Definition memory_write : Value.t -> Value.t -> M := " in let _ := M.assign (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) |), Constant.None_ |), - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_)). Definition memory_read_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "memory"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "memory"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from memory. @@ -90,20 +94,20 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.slice (| - M.get_name (| globals, "memory" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "memory" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) @@ -114,8 +118,9 @@ Definition memory_read_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition buffer_read : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "buffer"; "start_position"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "buffer"; "start_position"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Read bytes from a buffer. Padding with zeros if necessary. @@ -135,30 +140,30 @@ Definition buffer_read : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "right_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "right_pad_zero_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "buffer" |), - M.get_name (| globals, "start_position" |), + M.get_name (| globals, locals_stack, "buffer" |), + M.get_name (| globals, locals_stack, "start_position" |), BinOp.add (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "start_position" |) + M.get_name (| globals, locals_stack, "start_position" |) ], make_dict [] |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) |), Constant.None_ |); - M.get_name (| globals, "size" |) + M.get_name (| globals, locals_stack, "size" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/__init__.v b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/__init__.v index 8931f02..c1cb983 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/__init__.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.precompiled_contracts.__init__". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.precompiled_contracts.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,7 +29,7 @@ Definition __all__ : Value.t := M.run ltac:(M.monadic ( Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x01" ], @@ -37,7 +39,7 @@ Definition ECRECOVER_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x02" ], @@ -47,7 +49,7 @@ Definition SHA256_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x03" ], @@ -57,7 +59,7 @@ Definition RIPEMD160_ADDRESS : Value.t := M.run ltac:(M.monadic ( Definition IDENTITY_ADDRESS : Value.t := M.run ltac:(M.monadic ( M.call (| - M.get_name (| globals, "hex_to_address" |), + M.get_name (| globals, locals_stack, "hex_to_address" |), make_list [ Constant.str "0x04" ], diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ecrecover.v b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ecrecover.v index 1d6afbb..3ffd572 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ecrecover.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ecrecover.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.precompiled_contracts.ecrecover". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.precompiled_contracts.ecrecover". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -45,8 +47,9 @@ Axiom ethereum_tangerine_whistle_vm_memory_imports_buffer_read : IsImported globals "ethereum.tangerine_whistle.vm.memory" "buffer_read". Definition ecrecover : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Decrypts the address using elliptic curve DSA recovery mechanism and writes the address to output. @@ -58,31 +61,31 @@ Definition ecrecover : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); - M.get_name (| globals, "GAS_ECRECOVER" |) + M.get_name (| globals, locals_stack, "evm" |); + M.get_name (| globals, locals_stack, "GAS_ECRECOVER" |) ], make_dict [] |) in let _ := M.assign_local (| "message_hash_bytes" , M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 0 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -95,9 +98,9 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "message_hash" , M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ - M.get_name (| globals, "message_hash_bytes" |) + M.get_name (| globals, locals_stack, "message_hash_bytes" |) ], make_dict [] |) @@ -105,21 +108,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "v" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -135,21 +138,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "r" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 64 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -165,21 +168,21 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "s" , M.call (| - M.get_field (| M.get_name (| globals, "U256" |), "from_be_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U256" |), "from_be_bytes" |), make_list [ M.call (| - M.get_name (| globals, "buffer_read" |), + M.get_name (| globals, locals_stack, "buffer_read" |), make_list [ - M.get_name (| globals, "data" |); + M.get_name (| globals, locals_stack, "data" |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 96 ], make_dict [] |); M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ Constant.int 32 ], @@ -197,12 +200,12 @@ Definition ecrecover : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 27 |), ltac:(M.monadic ( Compare.not_eq (| - M.get_name (| globals, "v" |), + M.get_name (| globals, locals_stack, "v" |), Constant.int 28 |) )) @@ -223,12 +226,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "r" |) + M.get_name (| globals, locals_stack, "r" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "r" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "r" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -248,12 +251,12 @@ Definition ecrecover : Value.t -> Value.t -> M := BoolOp.or (| Compare.gt_e (| Constant.int 0, - M.get_name (| globals, "s" |) + M.get_name (| globals, locals_stack, "s" |) |), ltac:(M.monadic ( Compare.gt_e (| - M.get_name (| globals, "s" |), - M.get_name (| globals, "SECP256K1N" |) + M.get_name (| globals, locals_stack, "s" |), + M.get_name (| globals, locals_stack, "SECP256K1N" |) |) )) |), @@ -272,9 +275,9 @@ Definition ecrecover : Value.t -> Value.t -> M := "address" , M.slice (| M.call (| - M.get_name (| globals, "keccak256" |), + M.get_name (| globals, locals_stack, "keccak256" |), make_list [ - M.get_name (| globals, "public_key" |) + M.get_name (| globals, locals_stack, "public_key" |) ], make_dict [] |), @@ -286,16 +289,16 @@ Definition ecrecover : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_address" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "address" |); + M.get_name (| globals, locals_stack, "address" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_address" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_address" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/identity.v b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/identity.v index 9226b27..667269e 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/identity.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/identity.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.precompiled_contracts.identity". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.precompiled_contracts.identity". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -34,8 +36,9 @@ Axiom ethereum_tangerine_whistle_vm_gas_imports_charge_gas : IsImported globals "ethereum.tangerine_whistle.vm.gas" "charge_gas". Definition identity : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the message data to output. @@ -46,21 +49,21 @@ Definition identity : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -74,21 +77,21 @@ Definition identity : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_IDENTITY" |), + M.get_name (| globals, locals_stack, "GAS_IDENTITY" |), BinOp.mult (| - M.get_name (| globals, "GAS_IDENTITY_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_IDENTITY_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "data" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "data" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/mapping.v b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/mapping.v index 450b048..f9cde09 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/mapping.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/mapping.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.precompiled_contracts.mapping". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.precompiled_contracts.mapping". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ripemd160.v b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ripemd160.v index 52fd66f..b907551 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ripemd160.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/ripemd160.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.precompiled_contracts.ripemd160". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.precompiled_contracts.ripemd160". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -39,8 +41,9 @@ Axiom ethereum_tangerine_whistle_vm_gas_imports_charge_gas : IsImported globals "ethereum.tangerine_whistle.vm.gas" "charge_gas". Definition ripemd160 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the ripemd160 hash to output. @@ -51,21 +54,21 @@ Definition ripemd160 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -79,14 +82,14 @@ Definition ripemd160 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_RIPEMD160" |), + M.get_name (| globals, locals_stack, "GAS_RIPEMD160" |), BinOp.mult (| - M.get_name (| globals, "GAS_RIPEMD160_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_RIPEMD160_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], @@ -96,10 +99,10 @@ Definition ripemd160 : Value.t -> Value.t -> M := "hash_bytes" , M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "new" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "new" |), make_list [ Constant.str "ripemd160"; - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), @@ -110,16 +113,16 @@ Definition ripemd160 : Value.t -> Value.t -> M := let _ := M.assign_local (| "padded_hash" , M.call (| - M.get_name (| globals, "left_pad_zero_bytes" |), + M.get_name (| globals, locals_stack, "left_pad_zero_bytes" |), make_list [ - M.get_name (| globals, "hash_bytes" |); + M.get_name (| globals, locals_stack, "hash_bytes" |); Constant.int 32 ], make_dict [] |) |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), - M.get_name (| globals, "padded_hash" |) + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), + M.get_name (| globals, locals_stack, "padded_hash" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/sha256.v b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/sha256.v index 5144a3e..973a752 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/sha256.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/precompiled_contracts/sha256.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.precompiled_contracts.sha256". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.precompiled_contracts.sha256". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -36,8 +38,9 @@ Axiom ethereum_tangerine_whistle_vm_gas_imports_charge_gas : IsImported globals "ethereum.tangerine_whistle.vm.gas" "charge_gas". Definition sha256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm" ] in + ltac:(M.monadic ( let _ := Constant.str " Writes the sha256 hash to output. @@ -48,21 +51,21 @@ Definition sha256 : Value.t -> Value.t -> M := " in let _ := M.assign_local (| "data" , - M.get_field (| M.get_field (| M.get_name (| globals, "evm" |), "message" |), "data" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "message" |), "data" |) |) in let _ := M.assign_local (| "word_count" , BinOp.floor_div (| M.call (| - M.get_name (| globals, "ceil32" |), + M.get_name (| globals, locals_stack, "ceil32" |), make_list [ M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |) @@ -76,26 +79,26 @@ Definition sha256 : Value.t -> Value.t -> M := |) |) in let _ := M.call (| - M.get_name (| globals, "charge_gas" |), + M.get_name (| globals, locals_stack, "charge_gas" |), make_list [ - M.get_name (| globals, "evm" |); + M.get_name (| globals, locals_stack, "evm" |); BinOp.add (| - M.get_name (| globals, "GAS_SHA256" |), + M.get_name (| globals, locals_stack, "GAS_SHA256" |), BinOp.mult (| - M.get_name (| globals, "GAS_SHA256_WORD" |), - M.get_name (| globals, "word_count" |) + M.get_name (| globals, locals_stack, "GAS_SHA256_WORD" |), + M.get_name (| globals, locals_stack, "word_count" |) |) |) ], make_dict [] |) in let _ := M.assign (| - M.get_field (| M.get_name (| globals, "evm" |), "output" |), + M.get_field (| M.get_name (| globals, locals_stack, "evm" |), "output" |), M.call (| M.get_field (| M.call (| - M.get_field (| M.get_name (| globals, "hashlib" |), "sha256" |), + M.get_field (| M.get_name (| globals, locals_stack, "hashlib" |), "sha256" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |), "digest" |), diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/runtime.v b/CoqOfPython/ethereum/tangerine_whistle/vm/runtime.v index fc5eb03..b22af1f 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/runtime.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/runtime.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.runtime". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.runtime". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -27,8 +29,9 @@ Axiom ethereum_tangerine_whistle_vm_instructions_imports_Ops : IsImported globals "ethereum.tangerine_whistle.vm.instructions" "Ops". Definition get_valid_jump_destinations : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "code" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "code" ] in + ltac:(M.monadic ( let _ := Constant.str " Analyze the evm code to obtain the set of valid jump destinations. @@ -53,7 +56,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "valid_jump_destinations" , M.call (| - M.get_name (| globals, "set" |), + M.get_name (| globals, locals_stack, "set" |), make_list [], make_dict [] |) @@ -61,7 +64,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_local (| "pc" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -71,11 +74,11 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.while (| Compare.lt (| - M.get_name (| globals, "pc" |), + M.get_name (| globals, locals_stack, "pc" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "code" |) + M.get_name (| globals, locals_stack, "code" |) ], make_dict [] |) @@ -86,15 +89,15 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "current_opcode" |), - M.get_field (| M.get_name (| globals, "Ops" |), "JUMPDEST" |) + M.get_name (| globals, locals_stack, "current_opcode" |), + M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "JUMPDEST" |) |), (* then *) ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "valid_jump_destinations" |), "add" |), + M.get_field (| M.get_name (| globals, locals_stack, "valid_jump_destinations" |), "add" |), make_list [ - M.get_name (| globals, "pc" |) + M.get_name (| globals, locals_stack, "pc" |) ], make_dict [] |) in @@ -106,13 +109,13 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := M.if_then_else (| BoolOp.and (| Compare.lt_e (| - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |), - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |) + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |), + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |) |), ltac:(M.monadic ( Compare.lt_e (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH32" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH32" |), "value" |) |) )) |), @@ -122,8 +125,8 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := "push_data_size" , BinOp.add (| BinOp.sub (| - M.get_field (| M.get_name (| globals, "current_opcode" |), "value" |), - M.get_field (| M.get_field (| M.get_name (| globals, "Ops" |), "PUSH1" |), "value" |) + M.get_field (| M.get_name (| globals, locals_stack, "current_opcode" |), "value" |), + M.get_field (| M.get_field (| M.get_name (| globals, locals_stack, "Ops" |), "PUSH1" |), "value" |) |), Constant.int 1 |) @@ -131,7 +134,7 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := let _ := M.assign_op_local (| BinOp.add, "pc", - M.get_name (| globals, "push_data_size" |) + M.get_name (| globals, locals_stack, "push_data_size" |) |) in M.pure Constant.None_ (* else *) @@ -152,6 +155,6 @@ Definition get_valid_jump_destinations : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "valid_jump_destinations" |) + M.get_name (| globals, locals_stack, "valid_jump_destinations" |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/tangerine_whistle/vm/stack.v b/CoqOfPython/ethereum/tangerine_whistle/vm/stack.v index 6311bf2..2a61b4d 100644 --- a/CoqOfPython/ethereum/tangerine_whistle/vm/stack.v +++ b/CoqOfPython/ethereum/tangerine_whistle/vm/stack.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.tangerine_whistle.vm.stack". +Definition globals : Globals.t := "ethereum.tangerine_whistle.vm.stack". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -29,8 +31,9 @@ Axiom ethereum_tangerine_whistle_vm_exceptions_imports_StackUnderflowError : IsImported globals "ethereum.tangerine_whistle.vm.exceptions" "StackUnderflowError". Definition pop : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack" ] in + ltac:(M.monadic ( let _ := Constant.str " Pops the top item off of `stack`. @@ -50,9 +53,9 @@ Definition pop : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -60,7 +63,7 @@ Definition pop : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackUnderflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackUnderflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -68,7 +71,7 @@ Definition pop : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "pop" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "pop" |), make_list [], make_dict [] |) @@ -76,8 +79,9 @@ Definition pop : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition push : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "stack"; "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "stack"; "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Pushes `value` onto `stack`. @@ -95,9 +99,9 @@ Definition push : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "stack" |) + M.get_name (| globals, locals_stack, "stack" |) ], make_dict [] |), @@ -105,7 +109,7 @@ Definition push : Value.t -> Value.t -> M := |), (* then *) ltac:(M.monadic ( - let _ := M.raise (| Some (M.get_name (| globals, "StackOverflowError" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "StackOverflowError" |)) |) in M.pure Constant.None_ (* else *) )), ltac:(M.monadic ( @@ -113,9 +117,9 @@ Definition push : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "stack" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "stack" |), "append" |), make_list [ - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) ], make_dict [] |) diff --git a/CoqOfPython/ethereum/trace.v b/CoqOfPython/ethereum/trace.v index c659277..35d4510 100644 --- a/CoqOfPython/ethereum/trace.v +++ b/CoqOfPython/ethereum/trace.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.trace". +Definition globals : Globals.t := "ethereum.trace". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -121,14 +123,15 @@ Definition GasAndRefund : Value.t := Definition TraceEvent : Value.t := M.run ltac:(M.monadic ( M.get_subscript (| - M.get_name (| globals, "Union" |), - make_tuple [ M.get_name (| globals, "TransactionStart" |); M.get_name (| globals, "TransactionEnd" |); M.get_name (| globals, "PrecompileStart" |); M.get_name (| globals, "PrecompileEnd" |); M.get_name (| globals, "OpStart" |); M.get_name (| globals, "OpEnd" |); M.get_name (| globals, "OpException" |); M.get_name (| globals, "EvmStop" |); M.get_name (| globals, "GasAndRefund" |) ] + M.get_name (| globals, locals_stack, "Union" |), + make_tuple [ M.get_name (| globals, locals_stack, "TransactionStart" |); M.get_name (| globals, locals_stack, "TransactionEnd" |); M.get_name (| globals, locals_stack, "PrecompileStart" |); M.get_name (| globals, locals_stack, "PrecompileEnd" |); M.get_name (| globals, locals_stack, "OpStart" |); M.get_name (| globals, locals_stack, "OpEnd" |); M.get_name (| globals, locals_stack, "OpException" |); M.get_name (| globals, locals_stack, "EvmStop" |); M.get_name (| globals, locals_stack, "GasAndRefund" |) ] |) )). Definition evm_trace : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "evm"; "event"; "trace_memory"; "trace_stack"; "trace_return_data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "evm"; "event"; "trace_memory"; "trace_stack"; "trace_return_data" ] in + ltac:(M.monadic ( let _ := Constant.str " Create a trace of the event. " in diff --git a/CoqOfPython/ethereum/utils/__init__.v b/CoqOfPython/ethereum/utils/__init__.v index aa7d70b..06bbfea 100644 --- a/CoqOfPython/ethereum/utils/__init__.v +++ b/CoqOfPython/ethereum/utils/__init__.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.utils.__init__". +Definition globals : Globals.t := "ethereum.utils.__init__". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " diff --git a/CoqOfPython/ethereum/utils/byte.v b/CoqOfPython/ethereum/utils/byte.v index 07efce7..6f96c51 100644 --- a/CoqOfPython/ethereum/utils/byte.v +++ b/CoqOfPython/ethereum/utils/byte.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.utils.byte". +Definition globals : Globals.t := "ethereum.utils.byte". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -21,8 +23,9 @@ Axiom ethereum_base_types_imports_Bytes : IsImported globals "ethereum.base_types" "Bytes". Definition left_pad_zero_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Left pad zeroes to `value` if it's length is less than the given `size`. @@ -40,9 +43,9 @@ Definition left_pad_zero_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "value" |), "rjust" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "rjust" |), make_list [ - M.get_name (| globals, "size" |); + M.get_name (| globals, locals_stack, "size" |); Constant.bytes "00" ], make_dict [] @@ -51,8 +54,9 @@ Definition left_pad_zero_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition right_pad_zero_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "size" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "size" ] in + ltac:(M.monadic ( let _ := Constant.str " Right pad zeroes to `value` if it's length is less than the given `size`. @@ -70,9 +74,9 @@ Definition right_pad_zero_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "value" |), "ljust" |), + M.get_field (| M.get_name (| globals, locals_stack, "value" |), "ljust" |), make_list [ - M.get_name (| globals, "size" |); + M.get_name (| globals, locals_stack, "size" |); Constant.bytes "00" ], make_dict [] diff --git a/CoqOfPython/ethereum/utils/ensure.v b/CoqOfPython/ethereum/utils/ensure.v index 88c6e02..23f1393 100644 --- a/CoqOfPython/ethereum/utils/ensure.v +++ b/CoqOfPython/ethereum/utils/ensure.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.utils.ensure". +Definition globals : Globals.t := "ethereum.utils.ensure". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -23,8 +25,9 @@ Axiom typing_imports_Union : IsImported globals "typing" "Union". Definition ensure : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value"; "exception" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value"; "exception" ] in + ltac:(M.monadic ( let _ := Constant.str " Does nothing if `value` is truthy, otherwise raises the exception returned by `exception_class`. @@ -41,7 +44,7 @@ Definition ensure : Value.t -> Value.t -> M := let _ := (* if *) M.if_then_else (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), (* then *) ltac:(M.monadic ( let _ := M.return_ (| @@ -52,5 +55,5 @@ Definition ensure : Value.t -> Value.t -> M := )), ltac:(M.monadic ( M.pure Constant.None_ )) |) in - let _ := M.raise (| Some (M.get_name (| globals, "exception" |)) |) in + let _ := M.raise (| Some (M.get_name (| globals, locals_stack, "exception" |)) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/utils/hexadecimal.v b/CoqOfPython/ethereum/utils/hexadecimal.v index 822bc50..755d10a 100644 --- a/CoqOfPython/ethereum/utils/hexadecimal.v +++ b/CoqOfPython/ethereum/utils/hexadecimal.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.utils.hexadecimal". +Definition globals : Globals.t := "ethereum.utils.hexadecimal". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -38,8 +40,9 @@ Axiom ethereum_crypto_hash_imports_Hash32 : IsImported globals "ethereum.crypto.hash" "Hash32". Definition has_hex_prefix : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Check if a hex string starts with hex prefix (0x). @@ -55,7 +58,7 @@ Definition has_hex_prefix : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "hex_string" |), "startswith" |), + M.get_field (| M.get_name (| globals, locals_stack, "hex_string" |), "startswith" |), make_list [ Constant.str "0x" ], @@ -65,8 +68,9 @@ Definition has_hex_prefix : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition remove_hex_prefix : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Remove 0x prefix from a hex string if present. This function returns the passed hex string if it isn't prefixed with 0x. @@ -85,9 +89,9 @@ Definition remove_hex_prefix : Value.t -> Value.t -> M := (* if *) M.if_then_else (| M.call (| - M.get_name (| globals, "has_hex_prefix" |), + M.get_name (| globals, locals_stack, "has_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), @@ -95,9 +99,9 @@ Definition remove_hex_prefix : Value.t -> Value.t -> M := ltac:(M.monadic ( let _ := M.return_ (| M.slice (| - M.get_name (| globals, "hex_string" |), + M.get_name (| globals, locals_stack, "hex_string" |), M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ Constant.str "0x" ], @@ -113,13 +117,14 @@ Definition remove_hex_prefix : Value.t -> Value.t -> M := M.pure Constant.None_ )) |) in let _ := M.return_ (| - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) |) in M.pure Constant.None_)). Definition hex_to_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to bytes. @@ -135,12 +140,12 @@ Definition hex_to_bytes : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -151,8 +156,9 @@ Definition hex_to_bytes : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bytes8 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to 8 bytes. @@ -168,16 +174,16 @@ Definition hex_to_bytes8 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes8" |), + M.get_name (| globals, locals_stack, "Bytes8" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), @@ -197,8 +203,9 @@ Definition hex_to_bytes8 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bytes20 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to 20 bytes. @@ -214,16 +221,16 @@ Definition hex_to_bytes20 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes20" |), + M.get_name (| globals, locals_stack, "Bytes20" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), @@ -243,8 +250,9 @@ Definition hex_to_bytes20 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bytes32 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to 32 bytes. @@ -260,16 +268,16 @@ Definition hex_to_bytes32 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes32" |), + M.get_name (| globals, locals_stack, "Bytes32" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), @@ -289,8 +297,9 @@ Definition hex_to_bytes32 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_bytes256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to 256 bytes. @@ -306,16 +315,16 @@ Definition hex_to_bytes256 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Bytes256" |), + M.get_name (| globals, locals_stack, "Bytes256" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| M.get_field (| M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |), "rjust" |), @@ -335,8 +344,9 @@ Definition hex_to_bytes256 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_hash : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to hash32 (32 bytes). @@ -352,15 +362,15 @@ Definition hex_to_hash : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Hash32" |), + M.get_name (| globals, locals_stack, "Hash32" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "bytes" |), "fromhex" |), + M.get_field (| M.get_name (| globals, locals_stack, "bytes" |), "fromhex" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |) @@ -374,8 +384,9 @@ Definition hex_to_hash : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_uint : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to Uint. @@ -391,15 +402,15 @@ Definition hex_to_uint : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |); @@ -414,8 +425,9 @@ Definition hex_to_uint : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_u64 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to U64. @@ -431,15 +443,15 @@ Definition hex_to_u64 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "U64" |), + M.get_name (| globals, locals_stack, "U64" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |); @@ -454,8 +466,9 @@ Definition hex_to_u64 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition hex_to_u256 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "hex_string" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "hex_string" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert hex string to U256. @@ -471,15 +484,15 @@ Definition hex_to_u256 : Value.t -> Value.t -> M := " in let _ := M.return_ (| M.call (| - M.get_name (| globals, "U256" |), + M.get_name (| globals, locals_stack, "U256" |), make_list [ M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ M.call (| - M.get_name (| globals, "remove_hex_prefix" |), + M.get_name (| globals, locals_stack, "remove_hex_prefix" |), make_list [ - M.get_name (| globals, "hex_string" |) + M.get_name (| globals, locals_stack, "hex_string" |) ], make_dict [] |); diff --git a/CoqOfPython/ethereum/utils/numeric.v b/CoqOfPython/ethereum/utils/numeric.v index a3fc348..d616a17 100644 --- a/CoqOfPython/ethereum/utils/numeric.v +++ b/CoqOfPython/ethereum/utils/numeric.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.utils.numeric". +Definition globals : Globals.t := "ethereum.utils.numeric". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -28,8 +30,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition get_sign : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Determines the sign of a number. @@ -48,7 +51,7 @@ Definition get_sign : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) @@ -63,7 +66,7 @@ Definition get_sign : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "value" |), + M.get_name (| globals, locals_stack, "value" |), Constant.int 0 |), (* then *) @@ -84,8 +87,9 @@ Definition get_sign : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition ceil32 : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "value" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "value" ] in + ltac:(M.monadic ( let _ := Constant.str " Converts a unsigned integer to the next closest multiple of 32. @@ -104,7 +108,7 @@ Definition ceil32 : Value.t -> Value.t -> M := let _ := M.assign_local (| "ceiling" , M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 32 ], @@ -114,17 +118,17 @@ Definition ceil32 : Value.t -> Value.t -> M := let _ := M.assign_local (| "remainder" , BinOp.mod_ (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ceiling" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ceiling" |) |) |) in let _ := (* if *) M.if_then_else (| Compare.eq (| - M.get_name (| globals, "remainder" |), + M.get_name (| globals, locals_stack, "remainder" |), M.call (| - M.get_name (| globals, "Uint" |), + M.get_name (| globals, locals_stack, "Uint" |), make_list [ Constant.int 0 ], @@ -134,7 +138,7 @@ Definition ceil32 : Value.t -> Value.t -> M := (* then *) ltac:(M.monadic ( let _ := M.return_ (| - M.get_name (| globals, "value" |) + M.get_name (| globals, locals_stack, "value" |) |) in M.pure Constant.None_ (* else *) @@ -142,10 +146,10 @@ Definition ceil32 : Value.t -> Value.t -> M := let _ := M.return_ (| BinOp.sub (| BinOp.add (| - M.get_name (| globals, "value" |), - M.get_name (| globals, "ceiling" |) + M.get_name (| globals, locals_stack, "value" |), + M.get_name (| globals, locals_stack, "ceiling" |) |), - M.get_name (| globals, "remainder" |) + M.get_name (| globals, locals_stack, "remainder" |) |) |) in M.pure Constant.None_ @@ -153,8 +157,9 @@ Definition ceil32 : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition is_prime : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "number" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "number" ] in + ltac:(M.monadic ( let _ := Constant.str " Checks if `number` is a prime number. @@ -172,7 +177,7 @@ Definition is_prime : Value.t -> Value.t -> M := (* if *) M.if_then_else (| Compare.lt_e (| - M.get_name (| globals, "number" |), + M.get_name (| globals, locals_stack, "number" |), Constant.int 1 |), (* then *) @@ -187,17 +192,17 @@ Definition is_prime : Value.t -> Value.t -> M := )) |) in let _ := M.for_ (| - M.get_name (| globals, "x" |), + M.get_name (| globals, locals_stack, "x" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 2; BinOp.add (| M.call (| - M.get_name (| globals, "int" |), + M.get_name (| globals, locals_stack, "int" |), make_list [ BinOp.pow (| - M.get_name (| globals, "number" |), + M.get_name (| globals, locals_stack, "number" |), Constant.float "0.5" |) ], @@ -214,8 +219,8 @@ Definition is_prime : Value.t -> Value.t -> M := M.if_then_else (| Compare.eq (| BinOp.mod_ (| - M.get_name (| globals, "number" |), - M.get_name (| globals, "x" |) + M.get_name (| globals, locals_stack, "number" |), + M.get_name (| globals, locals_stack, "x" |) |), Constant.int 0 |), @@ -241,8 +246,9 @@ Definition is_prime : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition le_bytes_to_uint32_sequence : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "data" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "data" ] in + ltac:(M.monadic ( let _ := Constant.str " Convert little endian byte stream `data` to a little endian U32 sequence i.e., the first U32 number of the sequence is the least @@ -266,15 +272,15 @@ Definition le_bytes_to_uint32_sequence : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), M.call (| - M.get_name (| globals, "range" |), + M.get_name (| globals, locals_stack, "range" |), make_list [ Constant.int 0; M.call (| - M.get_name (| globals, "len" |), + M.get_name (| globals, locals_stack, "len" |), make_list [ - M.get_name (| globals, "data" |) + M.get_name (| globals, locals_stack, "data" |) ], make_dict [] |); @@ -284,16 +290,16 @@ Definition le_bytes_to_uint32_sequence : Value.t -> Value.t -> M := |), ltac:(M.monadic ( let _ := M.call (| - M.get_field (| M.get_name (| globals, "sequence" |), "append" |), + M.get_field (| M.get_name (| globals, locals_stack, "sequence" |), "append" |), make_list [ M.call (| - M.get_field (| M.get_name (| globals, "U32" |), "from_le_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "U32" |), "from_le_bytes" |), make_list [ M.slice (| - M.get_name (| globals, "data" |), - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "data" |), + M.get_name (| globals, locals_stack, "i" |), BinOp.add (| - M.get_name (| globals, "i" |), + M.get_name (| globals, locals_stack, "i" |), Constant.int 4 |), Constant.None_ @@ -312,9 +318,9 @@ Definition le_bytes_to_uint32_sequence : Value.t -> Value.t -> M := |) in let _ := M.return_ (| M.call (| - M.get_name (| globals, "tuple" |), + M.get_name (| globals, locals_stack, "tuple" |), make_list [ - M.get_name (| globals, "sequence" |) + M.get_name (| globals, locals_stack, "sequence" |) ], make_dict [] |) @@ -322,8 +328,9 @@ Definition le_bytes_to_uint32_sequence : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition le_uint32_sequence_to_bytes : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "sequence" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "sequence" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain little endian byte stream from a little endian U32 sequence i.e., the first U32 number of the sequence is the least significant @@ -354,14 +361,14 @@ Definition le_uint32_sequence_to_bytes : Value.t -> Value.t -> M := |) in let _ := M.for_ (| - M.get_name (| globals, "item" |), - M.get_name (| globals, "sequence" |), + M.get_name (| globals, locals_stack, "item" |), + M.get_name (| globals, locals_stack, "sequence" |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "result_bytes", M.call (| - M.get_field (| M.get_name (| globals, "item" |), "to_le_bytes4" |), + M.get_field (| M.get_name (| globals, locals_stack, "item" |), "to_le_bytes4" |), make_list [], make_dict [] |) @@ -373,13 +380,14 @@ Definition le_uint32_sequence_to_bytes : Value.t -> Value.t -> M := )) |) in let _ := M.return_ (| - M.get_name (| globals, "result_bytes" |) + M.get_name (| globals, locals_stack, "result_bytes" |) |) in M.pure Constant.None_)). Definition le_uint32_sequence_to_uint : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "sequence" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "sequence" ] in + ltac:(M.monadic ( let _ := Constant.str " Obtain Uint from a U32 sequence assuming that this sequence is little endian i.e., the first U32 number of the sequence is the least @@ -399,18 +407,18 @@ Definition le_uint32_sequence_to_uint : Value.t -> Value.t -> M := let _ := M.assign_local (| "sequence_as_bytes" , M.call (| - M.get_name (| globals, "le_uint32_sequence_to_bytes" |), + M.get_name (| globals, locals_stack, "le_uint32_sequence_to_bytes" |), make_list [ - M.get_name (| globals, "sequence" |) + M.get_name (| globals, locals_stack, "sequence" |) ], make_dict [] |) |) in let _ := M.return_ (| M.call (| - M.get_field (| M.get_name (| globals, "Uint" |), "from_le_bytes" |), + M.get_field (| M.get_name (| globals, locals_stack, "Uint" |), "from_le_bytes" |), make_list [ - M.get_name (| globals, "sequence_as_bytes" |) + M.get_name (| globals, locals_stack, "sequence_as_bytes" |) ], make_dict [] |) @@ -418,8 +426,9 @@ Definition le_uint32_sequence_to_uint : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition taylor_exponential : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ "factor"; "numerator"; "denominator" ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ "factor"; "numerator"; "denominator" ] in + ltac:(M.monadic ( let _ := Constant.str " Approximates factor * e ** (numerator / denominator) using Taylor expansion. @@ -450,32 +459,32 @@ Definition taylor_exponential : Value.t -> Value.t -> M := let _ := M.assign_local (| "numerator_accumulated" , BinOp.mult (| - M.get_name (| globals, "factor" |), - M.get_name (| globals, "denominator" |) + M.get_name (| globals, locals_stack, "factor" |), + M.get_name (| globals, locals_stack, "denominator" |) |) |) in let _ := M.while (| Compare.gt (| - M.get_name (| globals, "numerator_accumulated" |), + M.get_name (| globals, locals_stack, "numerator_accumulated" |), Constant.int 0 |), ltac:(M.monadic ( let _ := M.assign_op_local (| BinOp.add, "output", - M.get_name (| globals, "numerator_accumulated" |) + M.get_name (| globals, locals_stack, "numerator_accumulated" |) |) in let _ := M.assign_local (| "numerator_accumulated" , BinOp.floor_div (| BinOp.mult (| - M.get_name (| globals, "numerator_accumulated" |), - M.get_name (| globals, "numerator" |) + M.get_name (| globals, locals_stack, "numerator_accumulated" |), + M.get_name (| globals, locals_stack, "numerator" |) |), BinOp.mult (| - M.get_name (| globals, "denominator" |), - M.get_name (| globals, "i" |) + M.get_name (| globals, locals_stack, "denominator" |), + M.get_name (| globals, locals_stack, "i" |) |) |) |) in @@ -492,8 +501,8 @@ Definition taylor_exponential : Value.t -> Value.t -> M := |) in let _ := M.return_ (| BinOp.floor_div (| - M.get_name (| globals, "output" |), - M.get_name (| globals, "denominator" |) + M.get_name (| globals, locals_stack, "output" |), + M.get_name (| globals, locals_stack, "denominator" |) |) |) in M.pure Constant.None_)). diff --git a/CoqOfPython/ethereum/utils/safe_arithmetic.v b/CoqOfPython/ethereum/utils/safe_arithmetic.v index 0702f0e..3134fee 100644 --- a/CoqOfPython/ethereum/utils/safe_arithmetic.v +++ b/CoqOfPython/ethereum/utils/safe_arithmetic.v @@ -1,6 +1,8 @@ Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "ethereum.utils.safe_arithmetic". +Definition globals : Globals.t := "ethereum.utils.safe_arithmetic". + +Definition locals_stack : list Locals.t := []. Definition expr_1 : Value.t := Constant.str " @@ -30,8 +32,9 @@ Axiom ethereum_base_types_imports_Uint : IsImported globals "ethereum.base_types" "Uint". Definition u256_safe_add : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ ] in + ltac:(M.monadic ( let _ := Constant.str " Adds together the given sequence of numbers. If the total sum of the numbers exceeds `U256.MAX_VALUE` then an exception is raised. @@ -61,8 +64,9 @@ Definition u256_safe_add : Value.t -> Value.t -> M := M.pure Constant.None_)). Definition u256_safe_multiply : Value.t -> Value.t -> M := - fun (args kwargs : Value.t) => ltac:(M.monadic ( - let _ := M.set_locals (| args, kwargs, [ ] |) in + fun (args kwargs : Value.t) => + let- locals_stack := M.create_locals locals_stack args kwargs [ ] in + ltac:(M.monadic ( let _ := Constant.str " Multiplies together the given sequence of numbers. If the net product of the numbers exceeds `U256.MAX_VALUE` then an exception is raised. @@ -91,7 +95,7 @@ Definition u256_safe_multiply : Value.t -> Value.t -> M := let _ := M.assign_local (| "result" , M.get_subscript (| - M.get_name (| globals, "numbers" |), + M.get_name (| globals, locals_stack, "numbers" |), Constant.int 0 |) |) in diff --git a/main.py b/main.py index 5f2596b..f01ed25 100644 --- a/main.py +++ b/main.py @@ -197,9 +197,10 @@ def generate_function_def_body(indent, node): params = "; ".join(f"\"{arg.arg}\"" for arg in node.args.args) body = generate_stmts(indent + 1, node.body) - return "fun (args kwargs : Value.t) => ltac:(M.monadic (\n" + \ + return "fun (args kwargs : Value.t) =>\n" + \ generate_indent(indent + 1) + \ - f"let _ := M.set_locals (| args, kwargs, [ {params} ] |) in\n" + \ + f"let- locals_stack := M.create_locals locals_stack args kwargs [ {params} ] in\n" + \ + generate_indent(indent + 1) + "ltac:(M.monadic (\n" + \ body + "))" @@ -602,7 +603,7 @@ def generate_expr(indent, is_with_paren, node: ast.expr): elif isinstance(node, ast.Name): return paren( is_with_paren, - f"M.get_name (| globals, \"{node.id}\" |)" + f"M.get_name (| globals, locals_stack, \"{node.id}\" |)" ) elif isinstance(node, ast.List): return generate_list(indent, is_with_paren, node.elts) @@ -726,7 +727,9 @@ def generate_arg(node): # Generate Coq code from the AST coq_code = f"""Require Import CoqOfPython.CoqOfPython. -Definition globals : string := "{globals}". +Definition globals : Globals.t := "{globals}". + +Definition locals_stack : list Locals.t := []. {generate_mod(parsed_tree)} """ From 71868b6a98a2710e83cdbb761ad91d862e2e615e Mon Sep 17 00:00:00 2001 From: Guillaume Claret Date: Sun, 12 May 2024 17:53:23 +0200 Subject: [PATCH 3/5] Definition of a simulation for the add function --- .../ethereum/crypto/simulations/hash.v | 26 +++ .../ethereum/paris/simulations/fork_types.v | 12 ++ .../ethereum/paris/simulations/state.v | 5 + .../paris/vm/instructions/proofs/arithmetic.v | 0 .../vm/instructions/simulations/arithmetic.v | 44 ++++ .../ethereum/paris/vm/simulations/__init__.v | 109 ++++++++++ .../paris/vm/simulations/exceptions.v | 20 ++ .../ethereum/paris/vm/simulations/gas.v | 55 +++++ .../ethereum/paris/vm/simulations/stack.v | 35 +++ CoqOfPython/ethereum/simulations/base_types.v | 201 ++++++++++++++++++ CoqOfPython/ethereum/simulations/exceptions.v | 7 + CoqOfPython/simulations/CoqOfPython.v | 94 ++++++++ CoqOfPython/simulations/builtins.v | 14 ++ 13 files changed, 622 insertions(+) create mode 100644 CoqOfPython/ethereum/crypto/simulations/hash.v create mode 100644 CoqOfPython/ethereum/paris/simulations/fork_types.v create mode 100644 CoqOfPython/ethereum/paris/simulations/state.v create mode 100644 CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v create mode 100644 CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v create mode 100644 CoqOfPython/ethereum/paris/vm/simulations/__init__.v create mode 100644 CoqOfPython/ethereum/paris/vm/simulations/exceptions.v create mode 100644 CoqOfPython/ethereum/paris/vm/simulations/gas.v create mode 100644 CoqOfPython/ethereum/paris/vm/simulations/stack.v create mode 100644 CoqOfPython/ethereum/simulations/base_types.v create mode 100644 CoqOfPython/ethereum/simulations/exceptions.v create mode 100644 CoqOfPython/simulations/CoqOfPython.v create mode 100644 CoqOfPython/simulations/builtins.v diff --git a/CoqOfPython/ethereum/crypto/simulations/hash.v b/CoqOfPython/ethereum/crypto/simulations/hash.v new file mode 100644 index 0000000..f2dcfeb --- /dev/null +++ b/CoqOfPython/ethereum/crypto/simulations/hash.v @@ -0,0 +1,26 @@ +Require Import CoqOfPython.CoqOfPython. + +Require ethereum.simulations.base_types. +Module Bytes := base_types.Bytes. +Module Bytes32 := base_types.Bytes32. +Module Bytes64 := base_types.Bytes64. + +Module Hash32. + Inductive t : Set := + | Make (hash : Bytes32.t). + + Definition get (hash : t) : Bytes32.t := + match hash with + | Make hash => hash + end. +End Hash32. + +Module Hash64. + Inductive t : Set := + | Make (hash : Bytes64.t). + + Definition get (hash : t) : Bytes64.t := + match hash with + | Make hash => hash + end. +End Hash64. diff --git a/CoqOfPython/ethereum/paris/simulations/fork_types.v b/CoqOfPython/ethereum/paris/simulations/fork_types.v new file mode 100644 index 0000000..1efcb6c --- /dev/null +++ b/CoqOfPython/ethereum/paris/simulations/fork_types.v @@ -0,0 +1,12 @@ +Require Import CoqOfPython.CoqOfPython. +Require ethereum.simulations.base_types. + +Module Address. + Inductive t : Set := + | Make (address : base_types.Bytes20.t). + + Definition get (address : t) : base_types.Bytes20.t := + match address with + | Make address => address + end. +End Address. diff --git a/CoqOfPython/ethereum/paris/simulations/state.v b/CoqOfPython/ethereum/paris/simulations/state.v new file mode 100644 index 0000000..38f5408 --- /dev/null +++ b/CoqOfPython/ethereum/paris/simulations/state.v @@ -0,0 +1,5 @@ +Require Import CoqOfPython.CoqOfPython. + +Module State. + Parameter t : Set. +End State. diff --git a/CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v b/CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v new file mode 100644 index 0000000..e69de29 diff --git a/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v b/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v new file mode 100644 index 0000000..19718be --- /dev/null +++ b/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v @@ -0,0 +1,44 @@ +Require Import CoqOfPython.CoqOfPython. +Require Import simulations.CoqOfPython. +Require Import simulations.builtins. + +Require ethereum.simulations.base_types. +Definition U255_CEIL_VALUE := base_types.U255_CEIL_VALUE. +Module U256 := base_types.U256. +Definition U256_CEIL_VALUE := base_types.U256_CEIL_VALUE. +Module Uint := base_types.Uint. + +Require ethereum.paris.vm.simulations.__init__. +Module Evm := __init__.Evm. + +Require ethereum.paris.vm.simulations.gas. +Definition GAS_EXPONENTIATION := gas.GAS_EXPONENTIATION. +Definition GAS_EXPONENTIATION_PER_BYTE := gas.GAS_EXPONENTIATION_PER_BYTE. +Definition GAS_LOW := gas.GAS_LOW. +Definition GAS_MID := gas.GAS_MID. +Definition GAS_VERY_LOW := gas.GAS_VERY_LOW. +Definition charge_gas := gas.charge_gas. + +Require ethereum.paris.vm.simulations.stack. +Definition pop := stack.pop. +Definition push := stack.push. + +Import simulations.CoqOfPython.Notations. + +Definition add : MS? Evm.t Exception.t unit := + (* STACK *) + letS? x := StateError.lift_lens Evm.Lens.stack pop in + letS? y := StateError.lift_lens Evm.Lens.stack pop in + + (* GAS *) + letS? _ := charge_gas GAS_VERY_LOW in + + (* OPERATION *) + let result := U256.wrapping_add x y in + + letS? _ := StateError.lift_lens Evm.Lens.stack (push result) in + + (* PROGRAM COUNTER *) + letS? _ := StateError.lift_lens Evm.Lens.pc (fun pc => (inl tt, Uint.__add__ pc (Uint.Make 1))) in + + returnS? tt. diff --git a/CoqOfPython/ethereum/paris/vm/simulations/__init__.v b/CoqOfPython/ethereum/paris/vm/simulations/__init__.v new file mode 100644 index 0000000..5fb9a63 --- /dev/null +++ b/CoqOfPython/ethereum/paris/vm/simulations/__init__.v @@ -0,0 +1,109 @@ +Require Import CoqOfPython.CoqOfPython. +Require Import simulations.CoqOfPython. + +Require ethereum.simulations.base_types. +Module U64 := base_types.U64. +Module U256 := base_types.U256. +Module Bytes := base_types.Bytes. +Module Bytes0 := base_types.Bytes0. +Module Bytes32 := base_types.Bytes32. +Module Uint := base_types.Uint. + +Require ethereum.crypto.simulations.hash. +Module Hash32 := hash.Hash32. + +Require ethereum.paris.simulations.fork_types. +Module Address := fork_types.Address. + +Require ethereum.paris.simulations.state. +Module State := state.State. + +Module Environment. + Record t : Set := { + caller : Address.t; + block_hashes : list Hash32.t; + origin : Address.t; + coinbase : Address.t; + number : Uint.t; + base_fee_per_gas : Uint.t; + gas_limit : Uint.t; + gas_price : Uint.t; + time : U256.t; + prev_randao : Bytes32.t; + state : State.t; + chain_id : U64.t; + traces : list unit + }. +End Environment. + +Module Message. + (** We parametrize this type by the environment. *) + Record t {Evm : Set} : Set := { + caller : Address.t; + target : Bytes0.t + Address.t; + current_target : Address.t; + gas : Uint.t; + value : U256.t; + data : Bytes.t; + code_address : option Address.t; + code : Bytes.t; + depth : Uint.t; + should_transfer_value : bool; + is_static : bool; + accessed_addresses : list Address.t; + accessed_storage_keys : list (Address.t * Bytes32.t); + parent_evm : option Evm + }. + Arguments t : clear implicits. +End Message. + +Module Evm. + (** We split the record as it is recursive in the [message] field, and we cannot have recursive + records. *) + Module Rest. + Record t : Set := { + pc : Uint.t; + stack : list (U256.t); + memory : list ascii; + code : Bytes.t; + gas_left : Uint.t; + env : Environment.t; + valid_jump_destinations : list Uint.t; + logs : list unit; + refund_counter : Z; + running : bool; + output : Bytes.t; + accounts_to_delete : list Address.t; + touched_accounts : list Address.t; + return_data : Bytes.t; + error : option Exception.t; + accessed_addresses : list Address.t; + accessed_storage_keys : list (Address.t * Bytes32.t) + }. + End Rest. + + Inductive t : Set := + | Make (message : Message.t t) (rest : Rest.t). + + Module Lens. + Definition message : Lens.t t (Message.t t) := {| + Lens.read '(Make message _) := message; + Lens.write '(Make _ rest) message := Make message rest; + |}. + + Definition pc : Lens.t t Uint.t := {| + Lens.read '(Make _ rest) := rest.(Rest.pc); + Lens.write '(Make message rest) pc := Make message rest<|Rest.pc := pc|>; + |}. + + Definition stack : Lens.t t (list U256.t) := {| + Lens.read '(Make _ rest) := rest.(Rest.stack); + Lens.write '(Make message rest) stack := Make message rest<|Rest.stack := stack|>; + |}. + + Definition memory : Lens.t t (list ascii) := {| + Lens.read '(Make _ rest) := rest.(Rest.memory); + Lens.write '(Make message rest) memory := Make message rest<|Rest.memory := memory|>; + |}. + End Lens. +End Evm. diff --git a/CoqOfPython/ethereum/paris/vm/simulations/exceptions.v b/CoqOfPython/ethereum/paris/vm/simulations/exceptions.v new file mode 100644 index 0000000..db4fc89 --- /dev/null +++ b/CoqOfPython/ethereum/paris/vm/simulations/exceptions.v @@ -0,0 +1,20 @@ +Require Import CoqOfPython.CoqOfPython. + +Module ExceptionalHalt. + Inductive t : Set := + | StackUnderflowError + | StackOverflowError + | OutOfGasError + | InvalidOpcode (code : Z) + | InvalidJumpDestError + | StackDepthLimitError + | WriteInStaticContext + | OutOfBoundsRead + | InvalidParameter + | InvalidContractPrefix + | AddressCollision. +End ExceptionalHalt. + +Module Revert. + Inductive t : Set :=. +End Revert. diff --git a/CoqOfPython/ethereum/paris/vm/simulations/gas.v b/CoqOfPython/ethereum/paris/vm/simulations/gas.v new file mode 100644 index 0000000..7cfb7ce --- /dev/null +++ b/CoqOfPython/ethereum/paris/vm/simulations/gas.v @@ -0,0 +1,55 @@ +Require Import CoqOfPython.CoqOfPython. +Require Import simulations.CoqOfPython. +Require Import simulations.builtins. + +Require ethereum.simulations.base_types. +Module U256 := base_types.U256. +Module Uint := base_types.Uint. + +Require ethereum.paris.vm.simulations.__init__. +Module Evm := __init__.Evm. + +Import simulations.CoqOfPython.Notations. + +Definition GAS_JUMPDEST := Uint.Make 1. +Definition GAS_BASE := Uint.Make 2. +Definition GAS_VERY_LOW := Uint.Make 3. +Definition GAS_STORAGE_SET := Uint.Make 20000. +Definition GAS_STORAGE_UPDATE := Uint.Make 5000. +Definition GAS_STORAGE_CLEAR_REFUND := Uint.Make 4800. +Definition GAS_LOW := Uint.Make 5. +Definition GAS_MID := Uint.Make 8. +Definition GAS_HIGH := Uint.Make 10. +Definition GAS_EXPONENTIATION := Uint.Make 10. +Definition GAS_EXPONENTIATION_PER_BYTE := Uint.Make 50. +Definition GAS_MEMORY := Uint.Make 3. +Definition GAS_KECCAK256 := Uint.Make 30. +Definition GAS_KECCAK256_WORD := Uint.Make 6. +Definition GAS_COPY := Uint.Make 3. +Definition GAS_BLOCK_HASH := Uint.Make 20. +Definition GAS_LOG := Uint.Make 375. +Definition GAS_LOG_DATA := Uint.Make 8. +Definition GAS_LOG_TOPIC := Uint.Make 375. +Definition GAS_CREATE := Uint.Make 32000. +Definition GAS_CODE_DEPOSIT := Uint.Make 200. +Definition GAS_ZERO := Uint.Make 0. +Definition GAS_NEW_ACCOUNT := Uint.Make 25000. +Definition GAS_CALL_VALUE := Uint.Make 9000. +Definition GAS_CALL_STIPEND := Uint.Make 2300. +Definition GAS_SELF_DESTRUCT := Uint.Make 5000. +Definition GAS_SELF_DESTRUCT_NEW_ACCOUNT := Uint.Make 25000. +Definition GAS_ECRECOVER := Uint.Make 3000. +Definition GAS_SHA256 := Uint.Make 60. +Definition GAS_SHA256_WORD := Uint.Make 12. +Definition GAS_RIPEMD160 := Uint.Make 600. +Definition GAS_RIPEMD160_WORD := Uint.Make 120. +Definition GAS_IDENTITY := Uint.Make 15. +Definition GAS_IDENTITY_WORD := Uint.Make 3. +Definition GAS_RETURN_DATA_COPY := Uint.Make 3. +Definition GAS_FAST_STEP := Uint.Make 5. +Definition GAS_BLAKE2_PER_ROUND := Uint.Make 1. +Definition GAS_COLD_SLOAD := Uint.Make 2100. +Definition GAS_COLD_ACCOUNT_ACCESS := Uint.Make 2600. +Definition GAS_WARM_ACCESS := Uint.Make 100. + +Parameter charge_gas : forall (amount : Uint.t), MS? Evm.t Exception.t unit. diff --git a/CoqOfPython/ethereum/paris/vm/simulations/stack.v b/CoqOfPython/ethereum/paris/vm/simulations/stack.v new file mode 100644 index 0000000..e50f7a7 --- /dev/null +++ b/CoqOfPython/ethereum/paris/vm/simulations/stack.v @@ -0,0 +1,35 @@ +Require Import CoqOfPython.CoqOfPython. +Require Import simulations.CoqOfPython. +Require Import simulations.builtins. + +Require Import simulations.base_types. +Module U256 := base_types.U256. + +Import simulations.CoqOfPython.Notations. + +Definition pop : MS? (list U256.t) Exception.t U256.t := + fun stack => + match stack with + | [] => + ( + inr (Exception.EthereumException ( + exceptions.EthereumException.ExceptionalHalt + exceptions.ExceptionalHalt.StackUnderflowError + )), + stack + ) + | x :: rest => (inl x, rest) + end. + +Definition push (value : U256.t) : MS? (list U256.t) Exception.t unit := + fun stack => + if Z.of_nat (List.length stack) =? 1024 then + ( + inr (Exception.EthereumException ( + exceptions.EthereumException.ExceptionalHalt + exceptions.ExceptionalHalt.StackOverflowError + )), + stack + ) + else + (inl tt, value :: stack). diff --git a/CoqOfPython/ethereum/simulations/base_types.v b/CoqOfPython/ethereum/simulations/base_types.v new file mode 100644 index 0000000..e7666b7 --- /dev/null +++ b/CoqOfPython/ethereum/simulations/base_types.v @@ -0,0 +1,201 @@ +Require Import CoqOfPython.CoqOfPython. +Require Import simulations.CoqOfPython. +Require Import simulations.builtins. + +Import simulations.CoqOfPython.Notations. + +Definition U255_CEIL_VALUE : Z := 2^255. + +Definition U256_CEIL_VALUE : Z := 2^256. + +Module Uint. + Inductive t : Set := + | Make (value : Z). + + Definition get (value : t) : Z := + match value with + | Make value => value + end. + + Definition __add__ (self right_ : t) : t := + Make (get self + get right_). +End Uint. + +Module FixedUint. + Record t : Set := { + MAX_VALUE : Z; + value : Z; + }. + + Definition __add__ (self right_ : t) : M? Exception.t t := + let result := (self.(value) + right_.(value))%Z in + if result >? self.(MAX_VALUE) then + Error.raise (Exception.ArithmeticError ArithmeticError.OverflowError) + else + return? {| + MAX_VALUE := self.(MAX_VALUE); + value := result; + |}. + + Definition wrapping_add (self right_ : t) : t := + let sum := (self.(value) + right_.(value))%Z in + {| + MAX_VALUE := self.(MAX_VALUE); + value := Z.modulo sum self.(MAX_VALUE); + |}. +End FixedUint. + +Module U256. + Inductive t : Set := + | Make (value : FixedUint.t). + + Definition of_Z (value : Z) : t := + Make {| + FixedUint.MAX_VALUE := 2^256 - 1; + FixedUint.value := value; + |}. + + Definition get (value : t) : FixedUint.t := + match value with + | Make value => value + end. + + Definition __add__ (self right_ : t) : M? Exception.t t := + let? result := FixedUint.__add__ (get self) (get right_) in + return? (Make result). + + Definition wrapping_add (self right_ : t) : t := + Make (FixedUint.wrapping_add (get self) (get right_)). +End U256. + +Module U32. + Inductive t : Set := + | Make (value : FixedUint.t). + + Definition of_Z (value : Z) : t := + Make {| + FixedUint.MAX_VALUE := 2^32 - 1; + FixedUint.value := value; + |}. + + Definition get (value : t) : FixedUint.t := + match value with + | Make value => value + end. +End U32. + +Module U64. + Inductive t : Set := + | Make (value : FixedUint.t). + + Definition of_Z (value : Z) : t := + Make {| + FixedUint.MAX_VALUE := 2^64 - 1; + FixedUint.value := value; + |}. + + Definition get (value : t) : FixedUint.t := + match value with + | Make value => value + end. +End U64. + +Module FixedBytes. + Inductive t : Set := + | Make (bytes : list ascii). + + Definition get (bytes : t) : list ascii := + match bytes with + | Make bytes => bytes + end. +End FixedBytes. + +Module Bytes0. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes0. + +Module Bytes4. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes4. + +Module Bytes8. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes8. + +Module Bytes20. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes20. + +Module Bytes32. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes32. + +Module Bytes48. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes48. + +Module Bytes64. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes64. + +Module Bytes256. + Inductive t : Set := + | Make (bytes : FixedBytes.t). + + Definition get (bytes : t) : FixedBytes.t := + match bytes with + | Make bytes => bytes + end. +End Bytes256. + +Module Bytes. + Inductive t : Set := + | Make (bytes : list ascii). + + Definition get (bytes : t) : list ascii := + match bytes with + | Make bytes => bytes + end. +End Bytes. diff --git a/CoqOfPython/ethereum/simulations/exceptions.v b/CoqOfPython/ethereum/simulations/exceptions.v new file mode 100644 index 0000000..d5e0926 --- /dev/null +++ b/CoqOfPython/ethereum/simulations/exceptions.v @@ -0,0 +1,7 @@ +Require Import CoqOfPython.CoqOfPython. +Require ethereum.paris.vm.simulations.exceptions. + +Module EthereumException. + Inductive t : Set := + | ExceptionalHalt (exn : exceptions.ExceptionalHalt.t). +End EthereumException. diff --git a/CoqOfPython/simulations/CoqOfPython.v b/CoqOfPython/simulations/CoqOfPython.v new file mode 100644 index 0000000..004649c --- /dev/null +++ b/CoqOfPython/simulations/CoqOfPython.v @@ -0,0 +1,94 @@ +Require Import CoqOfPython.CoqOfPython. + +Module Lens. + Record t {Big_A A : Set} : Set := { + read : Big_A -> A; + write : Big_A -> A -> Big_A + }. + Arguments t : clear implicits. +End Lens. + +(** ** Monads that are useful for the definition of simulations. *) + +Module Error. + Definition t (Error A : Set) : Set := A + Error. + + Definition return_ {Error A : Set} (value : A) : t Error A := inl value. + + Definition bind {Error A B : Set} (value : t Error A) (f : A -> t Error B) : t Error B := + match value with + | inl value => f value + | inr error => inr error + end. + + Definition raise {Error A : Set} (error : Error) : t Error A := inr error. +End Error. + +Module StateError. + Definition t (State Error A : Set) : Set := State -> (A + Error) * State. + + Definition return_ {State Error A : Set} (value : A) : t State Error A := + fun state => (inl value, state). + + Definition bind {State Error A B : Set} (value : t State Error A) (f : A -> t State Error B) : + t State Error B := + fun state => + let (value, state) := value state in + match value with + | inl value => f value state + | inr error => (inr error, state) + end. + + Definition read {State Error : Set} : t State Error State := + fun state => (inl state, state). + + Definition write {State Error : Set} (state : State) : t State Error unit := + fun _ => (inl tt, state). + + Definition raise {State Error A : Set} (msg : Error) : t State Error A := + fun state => (inr msg, state). + + Definition lift_from_error {State Error A : Set} (value : Error.t Error A) : t State Error A := + fun state => + (value, state). + + Definition lift_lens {Big_State State Error A : Set} + (lens : Lens.t Big_State State) + (value : t State Error A) : + t Big_State Error A := + fun big_state => + let (value, state) := value (lens.(Lens.read) big_state) in + (value, lens.(Lens.write) big_state state). +End StateError. + +Module Notations. + Notation "M?" := Error.t. + + Notation "return?" := Error.return_. + + Notation "'let?' x ':=' X 'in' Y" := + (Error.bind X (fun x => Y)) + (at level 200, x name, X at level 100, Y at level 200). + + Notation "'let?' ' x ':=' X 'in' Y" := + (Error.bind X (fun x => Y)) + (at level 200, x pattern, X at level 100, Y at level 200). + + Notation "MS?" := StateError.t. + + Notation "returnS?" := StateError.return_. + + Notation "'letS?' x ':=' X 'in' Y" := + (StateError.bind X (fun x => Y)) + (at level 200, x name, X at level 100, Y at level 200). + + Notation "'letS?' ' x ':=' X 'in' Y" := + (StateError.bind X (fun x => Y)) + (at level 200, x pattern, X at level 100, Y at level 200). + + Notation "readS?" := StateError.read. + + Notation "writeS?" := StateError.write. + + Notation "return?toS?" := StateError.lift_from_error. +End Notations. \ No newline at end of file diff --git a/CoqOfPython/simulations/builtins.v b/CoqOfPython/simulations/builtins.v new file mode 100644 index 0000000..cc29a8f --- /dev/null +++ b/CoqOfPython/simulations/builtins.v @@ -0,0 +1,14 @@ +Require Import CoqOfPython.CoqOfPython. +Require ethereum.simulations.exceptions. + +Module ArithmeticError. + Inductive t : Set := + | OverflowError. +End ArithmeticError. + +Module Exception. + (** Here we exhaustively desbribe which are the possible exceptions. *) + Inductive t : Set := + | ArithmeticError (exn : ArithmeticError.t) + | EthereumException (exn : exceptions.EthereumException.t). +End Exception. From c6d3d85b715fe3b76ee2526a44f9761f17d313bc Mon Sep 17 00:00:00 2001 From: Guillaume Claret Date: Sun, 12 May 2024 18:44:05 +0200 Subject: [PATCH 4/5] Add a definition for a Run.t predicate --- CoqOfPython/CoqOfPython.v | 24 +++- .../vm/instructions/simulations/arithmetic.v | 3 +- CoqOfPython/proofs/CoqOfPython.v | 130 ++++++++++++++++++ 3 files changed, 149 insertions(+), 8 deletions(-) create mode 100644 CoqOfPython/proofs/CoqOfPython.v diff --git a/CoqOfPython/CoqOfPython.v b/CoqOfPython/CoqOfPython.v index dc29d21..55fd816 100644 --- a/CoqOfPython/CoqOfPython.v +++ b/CoqOfPython/CoqOfPython.v @@ -98,7 +98,7 @@ Module Value. End Value. Module Locals. - Definition t : Set := Pointer.Mutable.t Value.t. + Definition t : Set := Pointer.t Value.t. End Locals. (** ** Constants *) @@ -144,7 +144,7 @@ Definition make_dict (dict : list (string * Value.t)) : Value.t := Module Primitive. Inductive t : Set -> Set := - | StateAlloc (object : Object.t Value.t) : t (Pointer.Mutable.t Value.t) + | StateAlloc (object : Object.t Value.t) : t (Pointer.t Value.t) | StateRead (mutable : Pointer.Mutable.t Value.t) : t (Object.t Value.t) | StateWrite (mutable : Pointer.Mutable.t Value.t) (update : Object.t Value.t) : t unit | GetInGlobals (globals : Globals.t) (name : string) : t Value.t. @@ -154,7 +154,7 @@ Module LowM. Inductive t (A : Set) : Set := | Pure (a : A) | CallPrimitive {B : Set} (primitive : Primitive.t B) (k : B -> t A) - | CallClosure {B : Set} (closure : Value.t) (args kwargs : Value.t) (k : B -> t A) + | CallClosure {B : Set} (closure : Data.t Value.t) (args kwargs : Value.t) (k : B -> t A) | Impossible. Arguments Pure {_}. Arguments CallPrimitive {_ _}. @@ -228,9 +228,6 @@ Module M. Definition call_primitive {A : Set} (primitive : Primitive.t A) : LowM.t A := LowM.CallPrimitive primitive LowM.Pure. - Definition call (f : Value.t) (args kwargs : Value.t) : M := - LowM.CallClosure f args kwargs LowM.Pure. - Definition get_object (value : Value.t) : LowM.t (Object.t Value.t) := let 'Value.Make _ _ pointer := value in match pointer with @@ -239,6 +236,13 @@ Module M. | Pointer.Mutable mutable => call_primitive (Primitive.StateRead mutable) end. + Definition call (f : Value.t) (args kwargs : Value.t) : M := + let- f_object := get_object f in + match f_object.(Object.internal) with + | Some f => LowM.CallClosure f args kwargs LowM.Pure + | None => LowM.Impossible + end. + Definition get_field (value : Value.t) (field : string) : M := let- obj := get_object value in match Dict.read obj.(Object.fields) field with @@ -253,6 +257,12 @@ Module M. Parameter slice : Value.t -> Value.t -> Value.t -> Value.t -> M. + Definition read (pointer : Pointer.t Value.t) : LowM.t (Object.t Value.t) := + match pointer with + | Pointer.Imm object => LowM.Pure object + | Pointer.Mutable mutable => call_primitive (Primitive.StateRead mutable) + end. + Fixpoint get_name_in_locals_stack (locals_stack : list Locals.t) (name : string) : @@ -260,7 +270,7 @@ Module M. match locals_stack with | [] => LowM.Pure None | locals :: locals_stack => - let- locals_object := call_primitive (Primitive.StateRead locals) in + let- locals_object := read locals in match Dict.read locals_object.(Object.fields) name with | Some value => LowM.Pure (Some value) | None => get_name_in_locals_stack locals_stack name diff --git a/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v b/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v index 19718be..ad6e132 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/simulations/arithmetic.v @@ -39,6 +39,7 @@ Definition add : MS? Evm.t Exception.t unit := letS? _ := StateError.lift_lens Evm.Lens.stack (push result) in (* PROGRAM COUNTER *) - letS? _ := StateError.lift_lens Evm.Lens.pc (fun pc => (inl tt, Uint.__add__ pc (Uint.Make 1))) in + letS? _ := StateError.lift_lens Evm.Lens.pc (fun pc => + (inl tt, Uint.__add__ pc (Uint.Make 1))) in returnS? tt. diff --git a/CoqOfPython/proofs/CoqOfPython.v b/CoqOfPython/proofs/CoqOfPython.v new file mode 100644 index 0000000..0a47aae --- /dev/null +++ b/CoqOfPython/proofs/CoqOfPython.v @@ -0,0 +1,130 @@ +Require Import CoqOfPython.CoqOfPython. + +Module State. + Class Trait (State Address : Set) : Type := { + get_Set (a : Address) : Set; + read (a : Address) : State -> option (get_Set a); + alloc_write (a : Address) : State -> get_Set a -> option State; + }. + + Module Valid. + (** A valid state should behave as map from address to optional values + of the type given by the address. A value is [None] while not + allocated, and [Some] once allocated. It is impossible to free + allocated values. *) + Record t `(Trait) : Prop := { + (* [alloc_write] can only fail on new cells *) + not_allocated (a : Address) (s : State) (v : get_Set a) : + match alloc_write a s v with + | Some _ => True + | None => read a s = None + end; + same (a : Address) (s : State) (v : get_Set a) : + match alloc_write a s v with + | Some s => read a s = Some v + | None => True + end; + different (a1 a2 : Address) (s : State) (v2 : get_Set a2) : + a1 <> a2 -> + match alloc_write a2 s v2 with + | Some s' => read a1 s' = read a1 s + | None => True + end; + }. + End Valid. +End State. + +Module Run. + Reserved Notation "{{ state | e ⇓ result | state' }}". + + Inductive t `{State.Trait} {A : Set} + (* Be aware of the order of parameters: the result and final state are at + the beginning. This is due to the way polymorphic types for inductive + work in Coq, and the fact that the result is always the same as we are + in continuation passing style. *) + (result : A) (state' : State) : + LowM.t A -> State -> Prop := + | Pure : + {{ state' | LowM.Pure result ⇓ result | state' }} + | CallPrimitiveStateAllocImmediate + (state : State) (object : Object.t Value.t) + (k : Pointer.t Value.t -> LowM.t A) : + {{ state | + k (Pointer.Imm object) ⇓ result + | state' }} -> + {{ state | + LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ result + | state' }} + | CallPrimitiveStateAllocMutable + (address : Address) + (value : State.get_Set address) + (object : Object.t Value.t) + (to_object : State.get_Set address -> Object.t Value.t) + (state : State) + (k : Pointer.t Value.t -> LowM.t A) : + object = to_object value -> + State.read address state = None -> + State.alloc_write address state value = Some state' -> + {{ state | + k (Pointer.Mutable (Pointer.Mutable.Make address to_object)) ⇓ result + | state' }} -> + {{ state | + LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ result + | state' }} + | CallPrimitiveStateRead + (address : Address) + (to_object : State.get_Set address -> Object.t Value.t) + (value : State.get_Set address) + (state : State) + (k : Object.t Value.t -> LowM.t A) : + let mutable := Pointer.Mutable.Make address to_object in + State.read address state = Some value -> + {{ state | + k (to_object value) ⇓ + result + | state' }} -> + {{ state | + LowM.CallPrimitive (Primitive.StateRead mutable) k ⇓ + result + | state' }} + | CallPrimitiveStateWrite + (address : Address) + (to_object : State.get_Set address -> Object.t Value.t) + (update : State.get_Set address) + (update' : Object.t Value.t) + (state state_inter : State) + (k : unit -> LowM.t A) : + let mutable := Pointer.Mutable.Make address to_object in + update' = to_object update -> + State.alloc_write address state update = Some state_inter -> + {{ state_inter | + k tt ⇓ + result + | state' }} -> + {{ state | + LowM.CallPrimitive (Primitive.StateWrite mutable update') k ⇓ + result + | state' }} + | CallClosure + (state state_inter : State) + (f : Value.t -> Value.t -> M) + (args kwargs : Value.t) + (value : Value.t + Exception.t) + (k : Value.t + Exception.t -> LowM.t A) : + let closure := Data.Closure f in + {{ state | + f args kwargs ⇓ + value + | state_inter }} -> + {{ state_inter | + k value ⇓ + result + | state' }} -> + {{ state | + LowM.CallClosure closure args kwargs k ⇓ + result + | state' }} + + where "{{ state | e ⇓ result | state' }}" := + (t result state' e state). +End Run. From 6d0e196157f58d7c1217544afa394f3a337d3df3 Mon Sep 17 00:00:00 2001 From: Guillaume Claret Date: Sun, 12 May 2024 22:17:56 +0200 Subject: [PATCH 5/5] Progress towards the verification of the add function --- CoqOfPython/CoqOfPython.v | 38 ++- .../paris/vm/instructions/proofs/arithmetic.v | 69 ++++++ CoqOfPython/ethereum/simulations/base_types.v | 13 +- CoqOfPython/proofs/CoqOfPython.v | 222 ++++++++++++------ CoqOfPython/proofs/heap.v | 37 +++ 5 files changed, 303 insertions(+), 76 deletions(-) create mode 100644 CoqOfPython/proofs/heap.v diff --git a/CoqOfPython/CoqOfPython.v b/CoqOfPython/CoqOfPython.v index 55fd816..4e197a9 100644 --- a/CoqOfPython/CoqOfPython.v +++ b/CoqOfPython/CoqOfPython.v @@ -8,13 +8,26 @@ From Hammer Require Export Tactics. Global Set Primitive Projections. Global Set Printing Projections. -Global Open Scope list_scope. Global Open Scope string_scope. -Global Open Scope Z_scope. +Global Open Scope list_scope. Global Open Scope type_scope. +Global Open Scope Z_scope. Export List.ListNotations. +Inductive sigS {A : Type} (P : A -> Set) : Set := +| existS : forall (x : A), P x -> sigS P. +Arguments existS {_ _}. + +Reserved Notation "{ x @ P }" (at level 0, x at level 99). +Reserved Notation "{ x : A @ P }" (at level 0, x at level 99). +Reserved Notation "{ ' pat : A @ P }" + (at level 0, pat strict pattern, format "{ ' pat : A @ P }"). + +Notation "{ x @ P }" := (sigS (fun x => P)) : type_scope. +Notation "{ x : A @ P }" := (sigS (A := A) (fun x => P)) : type_scope. +Notation "{ ' pat : A @ P }" := (sigS (A := A) (fun pat => P)) : type_scope. + Module Dict. Definition t (Value : Set) : Set := list (string * Value). @@ -70,6 +83,21 @@ Module Object. Arguments t : clear implicits. Arguments Build_t {_}. + Fixpoint fields_of_optional_dict {Value : Set} (optional_dict : list (string * option Value)) : + Dict.t Value := + match optional_dict with + | [] => [] + | (name, Some value) :: optional_dict => + Dict.write (fields_of_optional_dict optional_dict) name value + | (_, None) :: optional_dict => fields_of_optional_dict optional_dict + end. + + Definition make {Value : Set} (optional_dict : list (string * option Value)) : t Value := + {| + internal := None; + fields := fields_of_optional_dict optional_dict; + |}. + (** When an object is just a wrapper around the [Data.t] type. *) Definition wrapper {Value : Set} (data : Data.t Value) : t Value := {| @@ -81,8 +109,10 @@ End Object. Module Pointer. Module Mutable. Inductive t (Value : Set) : Set := - | Make {Address A : Set} (address : Address) (to_object : A -> Object.t Value). - Arguments Make {_ _ _}. + | Stack {A : Set} (index : nat) (to_object : A -> Object.t Value) + | Heap {Address A : Set} (address : Address) (to_object : A -> Object.t Value). + Arguments Stack {_ _}. + Arguments Heap {_ _ _}. End Mutable. Inductive t (Value : Set) : Set := diff --git a/CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v b/CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v index e69de29..bd9d4ee 100644 --- a/CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v +++ b/CoqOfPython/ethereum/paris/vm/instructions/proofs/arithmetic.v @@ -0,0 +1,69 @@ +Require Import CoqOfPython.CoqOfPython. +Require Import proofs.CoqOfPython. +Require Import simulations.CoqOfPython. +Require Import proofs.heap. + +Require ethereum.paris.vm.instructions.simulations.arithmetic. +Require ethereum.paris.vm.instructions.arithmetic. + +Require ethereum.simulations.base_types. +Module U256 := base_types.U256. + +Import Run. + +Module Option. + Definition map {A B} (f : A -> B) (x : option A) : option B := + match x with + | Some x => Some (f x) + | None => None + end. +End Option. + +Module AddLocals. + Record t : Set := { + x : option U256.t; + y : option U256.t; + result : option U256.t; + }. + + Definition init : t := + {| + x := None; + y := None; + result := None; + |}. + + Definition to_object (locals : t) : Object.t Value.t := + Object.make [ + ("x", Option.map U256.to_value locals.(x)); + ("y", Option.map U256.to_value locals.(y)); + ("result", Option.map U256.to_value locals.(result)) + ]. +End AddLocals. + +Lemma run_add (stack : Stack.t) (heap : Heap.t) : + let '(result, evm') := simulations.arithmetic.add heap.(Heap.evm) in + let result := + match result with + | inl tt => inl Constant.None_ + | inr exn => inr (Exception.Raise (Some Constant.None_)) + end in + let heap' := heap <| Heap.evm := evm' |> in + exists fresh_stack, + {{ stack, heap | + arithmetic.add (make_list []) (make_dict []) ⇓ + result + | stack ++ fresh_stack, heap' }}. +Proof. + destruct simulations.arithmetic.add as [result evm'] eqn:?. + unfold arithmetic.add, simulations.arithmetic.add in *. + cbn in *. + eexists. + apply (Run.CallPrimitiveStateAllocStack AddLocals.init AddLocals.to_object); [reflexivity |]. + cbn. + eapply Run.CallPrimitiveStateReadStack. + { now erewrite Stack.read_length_eq. } + { cbn. + admit. + } +Admitted. diff --git a/CoqOfPython/ethereum/simulations/base_types.v b/CoqOfPython/ethereum/simulations/base_types.v index e7666b7..864d5b2 100644 --- a/CoqOfPython/ethereum/simulations/base_types.v +++ b/CoqOfPython/ethereum/simulations/base_types.v @@ -4,6 +4,8 @@ Require Import simulations.builtins. Import simulations.CoqOfPython.Notations. +Definition globals : Globals.t := "ethereum.base_types". + Definition U255_CEIL_VALUE : Z := 2^255. Definition U256_CEIL_VALUE : Z := 2^256. @@ -56,9 +58,14 @@ Module U256. |}. Definition get (value : t) : FixedUint.t := - match value with - | Make value => value - end. + let 'Make value := value in + value. + + Definition to_Z (value : t) : Z := + FixedUint.value (get value). + + Definition to_value (value : t) : Value.t := + Value.Make globals "U256" (Pointer.Imm (Object.wrapper (Data.Integer (to_Z value)))). Definition __add__ (self right_ : t) : M? Exception.t t := let? result := FixedUint.__add__ (get self) (get right_) in diff --git a/CoqOfPython/proofs/CoqOfPython.v b/CoqOfPython/proofs/CoqOfPython.v index 0a47aae..474a8f2 100644 --- a/CoqOfPython/proofs/CoqOfPython.v +++ b/CoqOfPython/proofs/CoqOfPython.v @@ -1,130 +1,214 @@ Require Import CoqOfPython.CoqOfPython. -Module State. - Class Trait (State Address : Set) : Type := { +Module Stack. + Definition t : Set := + list {A : Set @ A}. + + Definition read : t -> nat -> option {A : Set @ A} := + List.nth_error (A := {A : Set @ A}). + + Fixpoint write {A : Set} (stack : t) (index : nat) (value : A) : t := + match stack, index with + | start :: stack, Datatypes.O => (existS A value) :: stack + | start :: stack, Datatypes.S index => start :: write stack index value + | [], _ => [] + end. + + Lemma read_length_eq {A : Set} (stack_start stack_end : t) : + read (stack_start ++ stack_end) (List.length stack_start) = + read stack_end 0. + Proof. + now induction stack_start. + Qed. +End Stack. + +(** The precise type of the heap is provided by the user. We only enforce some consistency + properties between the read and write operations. *) +Module Heap. + Class Trait (Heap Address : Set) : Type := { get_Set (a : Address) : Set; - read (a : Address) : State -> option (get_Set a); - alloc_write (a : Address) : State -> get_Set a -> option State; + read (a : Address) : Heap -> option (get_Set a); + alloc_write (a : Address) : Heap -> get_Set a -> option Heap; }. Module Valid. - (** A valid state should behave as map from address to optional values + (** A valid heap should behave as map from address to optional values of the type given by the address. A value is [None] while not allocated, and [Some] once allocated. It is impossible to free allocated values. *) Record t `(Trait) : Prop := { (* [alloc_write] can only fail on new cells *) - not_allocated (a : Address) (s : State) (v : get_Set a) : - match alloc_write a s v with + not_allocated (a : Address) (h : Heap) (v : get_Set a) : + match alloc_write a h v with | Some _ => True - | None => read a s = None + | None => read a h = None end; - same (a : Address) (s : State) (v : get_Set a) : - match alloc_write a s v with - | Some s => read a s = Some v + same (a : Address) (h : Heap) (v : get_Set a) : + match alloc_write a h v with + | Some h => read a h = Some v | None => True end; - different (a1 a2 : Address) (s : State) (v2 : get_Set a2) : + different (a1 a2 : Address) (h : Heap) (v2 : get_Set a2) : a1 <> a2 -> - match alloc_write a2 s v2 with - | Some s' => read a1 s' = read a1 s + match alloc_write a2 h v2 with + | Some h' => read a1 h' = read a1 h | None => True end; }. End Valid. -End State. +End Heap. Module Run. - Reserved Notation "{{ state | e ⇓ result | state' }}". + Reserved Notation "{{ stack , heap | e ⇓ result | stack' , heap' }}". - Inductive t `{State.Trait} {A : Set} - (* Be aware of the order of parameters: the result and final state are at + Inductive t `{Heap.Trait} {A : Set} + (* Be aware of the order of parameters: the result and final heap are at the beginning. This is due to the way polymorphic types for inductive work in Coq, and the fact that the result is always the same as we are in continuation passing style. *) - (result : A) (state' : State) : - LowM.t A -> State -> Prop := + {result : A} {stack' : Stack.t} {heap' : Heap} : + LowM.t A -> Stack.t -> Heap -> Prop := | Pure : - {{ state' | LowM.Pure result ⇓ result | state' }} + {{ stack', heap' | + LowM.Pure result ⇓ + result + | stack', heap' }} | CallPrimitiveStateAllocImmediate - (state : State) (object : Object.t Value.t) + (stack : Stack.t) (heap : Heap) (object : Object.t Value.t) (k : Pointer.t Value.t -> LowM.t A) : - {{ state | - k (Pointer.Imm object) ⇓ result - | state' }} -> - {{ state | - LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ result - | state' }} - | CallPrimitiveStateAllocMutable + {{ stack, heap | + k (Pointer.Imm object) ⇓ + result + | stack', heap' }} -> + {{ stack, heap | + LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ + result + | stack', heap' }} + | CallPrimitiveStateAllocStack {B : Set} + (value : B) + (to_object : B -> Object.t Value.t) + (object : Object.t Value.t) + (stack : Stack.t) (heap : Heap) + (k : Pointer.t Value.t -> LowM.t A) : + let stack_inter := (stack ++ [existS B value])%list in + let index := List.length stack in + let mutable := Pointer.Mutable.Stack index to_object in + object = to_object value -> + {{ stack_inter, heap | + k (Pointer.Mutable mutable) ⇓ + result + | stack', heap' }} -> + {{ stack, heap | + LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ + result + | stack', heap' }} + | CallPrimitiveStateAllocHeap (address : Address) - (value : State.get_Set address) + (value : Heap.get_Set address) (object : Object.t Value.t) - (to_object : State.get_Set address -> Object.t Value.t) - (state : State) + (to_object : Heap.get_Set address -> Object.t Value.t) + (stack : Stack.t) (heap heap_inter : Heap) (k : Pointer.t Value.t -> LowM.t A) : + let mutable := Pointer.Mutable.Heap address to_object in object = to_object value -> - State.read address state = None -> - State.alloc_write address state value = Some state' -> - {{ state | - k (Pointer.Mutable (Pointer.Mutable.Make address to_object)) ⇓ result - | state' }} -> - {{ state | - LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ result - | state' }} - | CallPrimitiveStateRead + Heap.read address heap = None -> + Heap.alloc_write address heap value = Some heap_inter -> + {{ stack, heap_inter | + k (Pointer.Mutable mutable) ⇓ + result + | stack', heap' }} -> + {{ stack, heap | + LowM.CallPrimitive (Primitive.StateAlloc object) k ⇓ + result + | stack', heap' }} + | CallPrimitiveStateReadStack {B : Set} + (index : nat) + (to_object : B -> Object.t Value.t) + (value : B) + (stack : Stack.t) (heap : Heap) + (k : Object.t Value.t -> LowM.t A) : + let mutable := Pointer.Mutable.Stack index to_object in + Stack.read stack index = Some (existS B value) -> + {{ stack, heap | + k (to_object value) ⇓ + result + | stack', heap' }} -> + {{ stack, heap | + LowM.CallPrimitive (Primitive.StateRead mutable) k ⇓ + result + | stack', heap' }} + | CallPrimitiveStateReadHeap (address : Address) - (to_object : State.get_Set address -> Object.t Value.t) - (value : State.get_Set address) - (state : State) + (to_object : Heap.get_Set address -> Object.t Value.t) + (value : Heap.get_Set address) + (stack : Stack.t) (heap : Heap) (k : Object.t Value.t -> LowM.t A) : - let mutable := Pointer.Mutable.Make address to_object in - State.read address state = Some value -> - {{ state | + let mutable := Pointer.Mutable.Heap address to_object in + Heap.read address heap = Some value -> + {{ stack, heap | k (to_object value) ⇓ result - | state' }} -> - {{ state | + | stack', heap' }} -> + {{ stack, heap | LowM.CallPrimitive (Primitive.StateRead mutable) k ⇓ result - | state' }} - | CallPrimitiveStateWrite + | stack', heap' }} + | CallPrimitiveStateWriteStack {B : Set} + (index : nat) + (to_object : B -> Object.t Value.t) + (update : B) + (update' : Object.t Value.t) + (stack : Stack.t) (heap : Heap) + (k : unit -> LowM.t A) : + let stack_inter := Stack.write stack index update in + let mutable := Pointer.Mutable.Stack index to_object in + update' = to_object update -> + {{ stack_inter, heap | + k tt ⇓ + result + | stack', heap' }} -> + {{ stack, heap | + LowM.CallPrimitive (Primitive.StateWrite mutable update') k ⇓ + result + | stack', heap' }} + | CallPrimitiveStateWriteHeap (address : Address) - (to_object : State.get_Set address -> Object.t Value.t) - (update : State.get_Set address) + (to_object : Heap.get_Set address -> Object.t Value.t) + (update : Heap.get_Set address) (update' : Object.t Value.t) - (state state_inter : State) + (stack : Stack.t) (heap heap_inter : Heap) (k : unit -> LowM.t A) : - let mutable := Pointer.Mutable.Make address to_object in + let mutable := Pointer.Mutable.Heap address to_object in update' = to_object update -> - State.alloc_write address state update = Some state_inter -> - {{ state_inter | + Heap.alloc_write address heap update = Some heap_inter -> + {{ stack, heap_inter | k tt ⇓ result - | state' }} -> - {{ state | + | stack', heap' }} -> + {{ stack, heap | LowM.CallPrimitive (Primitive.StateWrite mutable update') k ⇓ result - | state' }} + | stack', heap' }} | CallClosure - (state state_inter : State) + (stack stack_inter : Stack.t) (heap heap_inter : Heap) (f : Value.t -> Value.t -> M) (args kwargs : Value.t) (value : Value.t + Exception.t) (k : Value.t + Exception.t -> LowM.t A) : let closure := Data.Closure f in - {{ state | + {{ stack, heap | f args kwargs ⇓ value - | state_inter }} -> - {{ state_inter | + | stack_inter, heap_inter }} -> + {{ stack_inter, heap_inter | k value ⇓ result - | state' }} -> - {{ state | + | stack', heap' }} -> + {{ stack, heap | LowM.CallClosure closure args kwargs k ⇓ result - | state' }} + | stack', heap' }} - where "{{ state | e ⇓ result | state' }}" := - (t result state' e state). + where "{{ stack , heap | e ⇓ result | stack' , heap' }}" := + (t (result := result) (stack' := stack') (heap' := heap') e stack heap). End Run. diff --git a/CoqOfPython/proofs/heap.v b/CoqOfPython/proofs/heap.v new file mode 100644 index 0000000..5d336c0 --- /dev/null +++ b/CoqOfPython/proofs/heap.v @@ -0,0 +1,37 @@ +(** * The memory that we use to interpret the translated Python code. *) +Require Import CoqOfPython.CoqOfPython. +Require Import proofs.CoqOfPython. + +Require ethereum.paris.vm.simulations.__init__. +Module Evm := __init__.Evm. + +Module Address. + Inductive t : Set := + | Evm. +End Address. + +Module Heap. + Record t : Set := { + evm : Evm.t; + }. + + Global Instance I : Heap.Trait Heap.t Address.t := { + get_Set a := + match a with + | Address.Evm => Evm.t + end; + read a h := + match a with + | Address.Evm => Some h.(evm) + end; + alloc_write a h := + match a with + | Address.Evm => fun v => Some (h <| evm := v |>) + end; + }. + + Lemma is_valid : Heap.Valid.t I. + Proof. + sauto. + Qed. +End Heap.